lalrpop 0.7.0

#![allow(unused_imports)]
#![allow(unused_variables)]
use intern::{intern, InternedString};
use grammar::parse_tree::*;
use grammar::pattern::*;
use std::iter::once;
use tok::{self, Tok};
extern crate lalrpop_util as __lalrpop_util;
use self::__lalrpop_util::ParseError as __ParseError;
#[allow(non_snake_case)]
pub fn parse_Grammar<
    'input,
    __TOKEN: __ToTriple<'input, Error=tok::Error>,
    __TOKENS: IntoIterator<Item=__TOKEN>,
>(
    text: &'input str,
    __tokens: __TOKENS,
) -> Result<Grammar, __ParseError<usize,Tok<'input>,tok::Error>>
{
    let mut __tokens = __tokens.into_iter();
    let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t));
    let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
    match try!(__parse__Grammar::__state0(text, None, __lookahead, &mut __tokens)) {
        (_, Some(__lookahead), _) => {
            Err(__ParseError::ExtraToken { token: __lookahead })
        }
        (_, None, __parse__Grammar::__Nonterminal::____Grammar(__nt)) => {
            Ok(__nt)
        }
        _ => unreachable!(),
    }
}

mod __parse__Grammar {
    #![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports)]

    use intern::{intern, InternedString};
    use grammar::parse_tree::*;
    use grammar::pattern::*;
    use std::iter::once;
    use tok::{self, Tok};
    extern crate lalrpop_util as __lalrpop_util;
    use self::__lalrpop_util::ParseError as __ParseError;
    use super::__ToTriple;

    pub enum __Nonterminal<'input, > {
        ____Grammar(Grammar),
        Comma_3cNonterminalId_3e(Vec<NonterminalString>),
        _28_3cNonterminalId_3e_20_22_2c_22_29_2a(::std::vec::Vec<NonterminalString>),
        AssociatedType(AssociatedType),
        Action_3f(::std::option::Option<ActionKind>),
        GrammarParameter_3f(::std::option::Option<Parameter>),
        NonterminalId_3f(::std::option::Option<NonterminalString>),
        Alternatives(Vec<Alternative>),
        _28_3cId_3e_20_22_3a_3a_22_29_2a(::std::vec::Vec<InternedString>),
        _28_3cFieldPattern_3e_20_22_2c_22_29(FieldPattern<TypeRef>),
        _22where_22_3f(::std::option::Option<Vec<&'input str>>),
        Id(InternedString),
        _28_3cTypeRef_3e_20_22_2c_22_29(TypeRef),
        _40R(usize),
        GrammarTypeParameters_3f(::std::option::Option<Vec<TypeParameter>>),
        Use_2a(::std::vec::Vec<GrammarItem>),
        _28_3cConversion_3e_20_22_2c_22_29(Conversion),
        Symbol1(Symbol),
        GrammarItem(GrammarItem),
        RepeatOp(RepeatOp),
        ExprSymbol(ExprSymbol),
        Terminal(TerminalString),
        Symbol_3f(::std::option::Option<Symbol>),
        MacroId(NonterminalString),
        _28_22if_22_20_3cCond_3e_29(Condition),
        GrammarItem_2a(::std::vec::Vec<GrammarItem>),
        FieldPattern_3f(::std::option::Option<FieldPattern<TypeRef>>),
        _28_3cTypeRef_3e_20_22_2c_22_29_2a(::std::vec::Vec<TypeRef>),
        Comma_3cConversion_3e(Vec<Conversion>),
        Action(ActionKind),
        Cond(Condition),
        Conversion_3f(::std::option::Option<Conversion>),
        _28_3cFieldPattern_3e_20_22_2c_22_29_2a(::std::vec::Vec<FieldPattern<TypeRef>>),
        GrammarParameters(Vec<Parameter>),
        _22_3a_3a_22_3f(::std::option::Option<Tok<'input>>),
        TypeRefOrLifetime_3f(::std::option::Option<TypeRef>),
        _28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(::std::vec::Vec<TypeRef>),
        AssociatedType_2a(::std::vec::Vec<AssociatedType>),
        NonterminalName((NonterminalString, Vec<NonterminalString>)),
        Comma_3cTypeRefOrLifetime_3e(Vec<TypeRef>),
        FieldPattern(FieldPattern<TypeRef>),
        Escape(InternedString),
        Symbol0(Symbol),
        Pattern_3f(::std::option::Option<Pattern<TypeRef>>),
        _28_22if_22_20_3cCond_3e_29_3f(::std::option::Option<Condition>),
        _28_3cTypeParameter_3e_20_22_2c_22_29_2a(::std::vec::Vec<TypeParameter>),
        SymbolKind1(SymbolKind),
        Symbol(Symbol),
        Alternative(Alternative),
        _22mut_22_3f(::std::option::Option<Tok<'input>>),
        PatternKind(PatternKind<TypeRef>),
        GrammarTypeParameters(Vec<TypeParameter>),
        Path(Path),
        TypeRef_3f(::std::option::Option<TypeRef>),
        ExternToken(GrammarItem),
        Lifetime_3f(::std::option::Option<InternedString>),
        Comma_3cTypeRef_3e(Vec<TypeRef>),
        Comma_3cGrammarParameter_3e(Vec<Parameter>),
        Grammar(Grammar),
        _28_3cPattern_3e_20_22_2c_22_29_2a(::std::vec::Vec<Pattern<TypeRef>>),
        GrammarParameter(Parameter),
        _28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(TypeRef),
        _28_3cGrammarParameter_3e_20_22_2c_22_29(Parameter),
        _28_3cSymbol_3e_20_22_2c_22_29_2a(::std::vec::Vec<Symbol>),
        TypeRef(TypeRef),
        _28_22_3a_22_20_3cTypeRef_3e_29_3f(::std::option::Option<TypeRef>),
        Nonterminal(GrammarItem),
        Pattern(Pattern<TypeRef>),
        Conversion(Conversion),
        Use(GrammarItem),
        CondOp(ConditionOp),
        NonterminalId(NonterminalString),
        Comma_3cSymbol_3e(Vec<Symbol>),
        _28_3cSymbol_3e_20_22_2c_22_29(Symbol),
        _28_22_3a_22_20_3cTypeRef_3e_29(TypeRef),
        _28_3cId_3e_20_22_3a_3a_22_29(InternedString),
        Alternative_2a(::std::vec::Vec<Alternative>),
        _28_3cGrammarParameter_3e_20_22_2c_22_29_2a(::std::vec::Vec<Parameter>),
        _40L(usize),
        _28_3cTypeParameter_3e_20_22_2c_22_29(TypeParameter),
        Lifetime(InternedString),
        TypeParameter_3f(::std::option::Option<TypeParameter>),
        _28_3cConversion_3e_20_22_2c_22_29_2a(::std::vec::Vec<Conversion>),
        TypeParameter(TypeParameter),
        Comma_3cTypeParameter_3e(Vec<TypeParameter>),
        _28_3cNonterminalId_3e_20_22_2c_22_29(NonterminalString),
        _22pub_22_3f(::std::option::Option<Tok<'input>>),
        Comma_3cPattern_3e(Vec<Pattern<TypeRef>>),
        TypeRefOrLifetime(TypeRef),
        _28_3cPattern_3e_20_22_2c_22_29(Pattern<TypeRef>),
        GrammarParameters_3f(::std::option::Option<Vec<Parameter>>),
        Symbol_2a(::std::vec::Vec<Symbol>),
        ____Pattern(Pattern<TypeRef>),
        StringLiteral(InternedString),
    }

    // State 0
    //   Grammar = (*) Use* @L "grammar" @R GrammarTypeParameters? GrammarParameters? "where"? ";" GrammarItem* [EOF]
    //   Use* = (*) ["grammar"]
    //   Use* = (*) ["use"]
    //   Use* = (*) Use* Use ["grammar"]
    //   Use* = (*) Use* Use ["use"]
    //   __Grammar = (*) Grammar [EOF]
    //
    //   "use" -> Reduce(Use* =  => Call(ActionFn(119));)
    //   "grammar" -> Reduce(Use* =  => Call(ActionFn(119));)
    //
    //   Grammar -> S2
    //   Use* -> S1
    pub fn __state0<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Use(_), _)) => {
                let __nt = super::__action119(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Use_2a(__nt));
            }
            Some((_, Tok::Grammar(..), _)) => {
                let __nt = super::__action119(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Use_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        loop {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Grammar(__nt) => {
                    let __sym0 = &mut Some(__nt);
                    __result = try!(__state2(text, __lookbehind, __lookahead, __tokens, __sym0));
                }
                __Nonterminal::Use_2a(__nt) => {
                    let __sym0 = &mut Some(__nt);
                    __result = try!(__state1(text, __lookbehind, __lookahead, __tokens, __sym0));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
    }

    // State 1
    //   @L = (*) ["grammar"]
    //   Grammar = Use* (*) @L "grammar" @R GrammarTypeParameters? GrammarParameters? "where"? ";" GrammarItem* [EOF]
    //   Use = (*) "use" ";" ["grammar"]
    //   Use = (*) "use" ";" ["use"]
    //   Use* = Use* (*) Use ["grammar"]
    //   Use* = Use* (*) Use ["use"]
    //
    //   "use" -> Shift(S4)
    //   "grammar" -> Reduce(@L =  => Lookahead;)
    //
    //   @L -> S3
    //   Use -> S5
    pub fn __state1<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Use(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state4(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Grammar(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state3(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Use(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state5(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 2
    //   __Grammar = Grammar (*) [EOF]
    //
    //   EOF -> Reduce(__Grammar = Grammar => Call(ActionFn(0));)
    //
    pub fn __state2<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Grammar>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action0(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::____Grammar(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 3
    //   Grammar = Use* @L (*) "grammar" @R GrammarTypeParameters? GrammarParameters? "where"? ";" GrammarItem* [EOF]
    //
    //   "grammar" -> Shift(S6)
    //
    pub fn __state3<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Grammar(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 4
    //   Use = "use" (*) ";" ["grammar"]
    //   Use = "use" (*) ";" ["use"]
    //
    //   ";" -> Shift(S7)
    //
    pub fn __state4<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Semi(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state7(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 5
    //   Use* = Use* Use (*) ["grammar"]
    //   Use* = Use* Use (*) ["use"]
    //
    //   "use" -> Reduce(Use* = Use*, Use => Call(ActionFn(120));)
    //   "grammar" -> Reduce(Use* = Use*, Use => Call(ActionFn(120));)
    //
    pub fn __state5<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<GrammarItem>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action120(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use_2a(__nt)));
            }
            Some((_, Tok::Grammar(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action120(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 6
    //   @R = (*) ["("]
    //   @R = (*) [";"]
    //   @R = (*) ["<"]
    //   @R = (*) ["where"]
    //   Grammar = Use* @L "grammar" (*) @R GrammarTypeParameters? GrammarParameters? "where"? ";" GrammarItem* [EOF]
    //
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   ";" -> Reduce(@R =  => Lookbehind;)
    //   "where" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S8
    pub fn __state6<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Where(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state8(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 7
    //   Use = "use" ";" (*) ["grammar"]
    //   Use = "use" ";" (*) ["use"]
    //
    //   "grammar" -> Reduce(Use = "use", ";" => Call(ActionFn(11));)
    //   "use" -> Reduce(Use = "use", ";" => Call(ActionFn(11));)
    //
    pub fn __state7<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Grammar(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action11(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action11(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 8
    //   Grammar = Use* @L "grammar" @R (*) GrammarTypeParameters? GrammarParameters? "where"? ";" GrammarItem* [EOF]
    //   GrammarTypeParameters = (*) "<" Comma<TypeParameter> ">" ["("]
    //   GrammarTypeParameters = (*) "<" Comma<TypeParameter> ">" [";"]
    //   GrammarTypeParameters = (*) "<" Comma<TypeParameter> ">" ["where"]
    //   GrammarTypeParameters? = (*) ["("]
    //   GrammarTypeParameters? = (*) [";"]
    //   GrammarTypeParameters? = (*) ["where"]
    //   GrammarTypeParameters? = (*) GrammarTypeParameters ["("]
    //   GrammarTypeParameters? = (*) GrammarTypeParameters [";"]
    //   GrammarTypeParameters? = (*) GrammarTypeParameters ["where"]
    //
    //   ";" -> Reduce(GrammarTypeParameters? =  => Call(ActionFn(118));)
    //   "where" -> Reduce(GrammarTypeParameters? =  => Call(ActionFn(118));)
    //   "(" -> Reduce(GrammarTypeParameters? =  => Call(ActionFn(118));)
    //   "<" -> Shift(S11)
    //
    //   GrammarTypeParameters -> S9
    //   GrammarTypeParameters? -> S10
    pub fn __state8<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state11(text, __lookbehind, __lookahead, __tokens, __sym4));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action118(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarTypeParameters_3f(__nt));
            }
            Some((_, Tok::Where(_), _)) => {
                let __nt = super::__action118(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarTypeParameters_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action118(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarTypeParameters_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym3.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::GrammarTypeParameters(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state9(text, __lookbehind, __lookahead, __tokens, __sym4));
                }
                __Nonterminal::GrammarTypeParameters_3f(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state10(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 9
    //   GrammarTypeParameters? = GrammarTypeParameters (*) ["("]
    //   GrammarTypeParameters? = GrammarTypeParameters (*) [";"]
    //   GrammarTypeParameters? = GrammarTypeParameters (*) ["where"]
    //
    //   "where" -> Reduce(GrammarTypeParameters? = GrammarTypeParameters => Call(ActionFn(117));)
    //   "(" -> Reduce(GrammarTypeParameters? = GrammarTypeParameters => Call(ActionFn(117));)
    //   ";" -> Reduce(GrammarTypeParameters? = GrammarTypeParameters => Call(ActionFn(117));)
    //
    pub fn __state9<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Vec<TypeParameter>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Where(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action117(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarTypeParameters_3f(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action117(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarTypeParameters_3f(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action117(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarTypeParameters_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 10
    //   Grammar = Use* @L "grammar" @R GrammarTypeParameters? (*) GrammarParameters? "where"? ";" GrammarItem* [EOF]
    //   GrammarParameters = (*) "(" Comma<GrammarParameter> ")" [";"]
    //   GrammarParameters = (*) "(" Comma<GrammarParameter> ")" ["where"]
    //   GrammarParameters? = (*) [";"]
    //   GrammarParameters? = (*) ["where"]
    //   GrammarParameters? = (*) GrammarParameters [";"]
    //   GrammarParameters? = (*) GrammarParameters ["where"]
    //
    //   "where" -> Reduce(GrammarParameters? =  => Call(ActionFn(116));)
    //   "(" -> Shift(S13)
    //   ";" -> Reduce(GrammarParameters? =  => Call(ActionFn(116));)
    //
    //   GrammarParameters? -> S12
    //   GrammarParameters -> S14
    pub fn __state10<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<::std::option::Option<Vec<TypeParameter>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state13(text, __lookbehind, __lookahead, __tokens, __sym5));
            }
            Some((_, Tok::Where(_), _)) => {
                let __nt = super::__action116(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarParameters_3f(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action116(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarParameters_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym4.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::GrammarParameters_3f(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state12(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
                }
                __Nonterminal::GrammarParameters(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state14(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 11
    //   (<TypeParameter> ",")* = (*) [">"]
    //   (<TypeParameter> ",")* = (*) ["Id"]
    //   (<TypeParameter> ",")* = (*) ["Lifetime"]
    //   (<TypeParameter> ",")* = (*) (<TypeParameter> ",")* (<TypeParameter> ",") [">"]
    //   (<TypeParameter> ",")* = (*) (<TypeParameter> ",")* (<TypeParameter> ",") ["Id"]
    //   (<TypeParameter> ",")* = (*) (<TypeParameter> ",")* (<TypeParameter> ",") ["Lifetime"]
    //   Comma<TypeParameter> = (*) (<TypeParameter> ",")* TypeParameter? [">"]
    //   GrammarTypeParameters = "<" (*) Comma<TypeParameter> ">" ["("]
    //   GrammarTypeParameters = "<" (*) Comma<TypeParameter> ">" [";"]
    //   GrammarTypeParameters = "<" (*) Comma<TypeParameter> ">" ["where"]
    //
    //   "Id" -> Reduce((<TypeParameter> ",")* =  => Call(ActionFn(123));)
    //   "Lifetime" -> Reduce((<TypeParameter> ",")* =  => Call(ActionFn(123));)
    //   ">" -> Reduce((<TypeParameter> ",")* =  => Call(ActionFn(123));)
    //
    //   (<TypeParameter> ",")* -> S15
    //   Comma<TypeParameter> -> S16
    pub fn __state11<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action123(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __nt = super::__action123(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action123(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state15(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Comma_3cTypeParameter_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state16(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 12
    //   "where"? = (*) [";"]
    //   "where"? = (*) "where" [";"]
    //   Grammar = Use* @L "grammar" @R GrammarTypeParameters? GrammarParameters? (*) "where"? ";" GrammarItem* [EOF]
    //
    //   "where" -> Shift(S18)
    //   ";" -> Reduce("where"? =  => Call(ActionFn(114));)
    //
    //   "where"? -> S17
    pub fn __state12<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<::std::option::Option<Vec<TypeParameter>>>,
        __sym5: &mut Option<::std::option::Option<Vec<Parameter>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Where(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state18(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action114(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22where_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym5.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22where_22_3f(__nt) => {
                    let __sym6 = &mut Some(__nt);
                    __result = try!(__state17(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 13
    //   (<GrammarParameter> ",")* = (*) [")"]
    //   (<GrammarParameter> ",")* = (*) ["Id"]
    //   (<GrammarParameter> ",")* = (*) (<GrammarParameter> ",")* (<GrammarParameter> ",") [")"]
    //   (<GrammarParameter> ",")* = (*) (<GrammarParameter> ",")* (<GrammarParameter> ",") ["Id"]
    //   Comma<GrammarParameter> = (*) (<GrammarParameter> ",")* GrammarParameter? [")"]
    //   GrammarParameters = "(" (*) Comma<GrammarParameter> ")" [";"]
    //   GrammarParameters = "(" (*) Comma<GrammarParameter> ")" ["where"]
    //
    //   "Id" -> Reduce((<GrammarParameter> ",")* =  => Call(ActionFn(128));)
    //   ")" -> Reduce((<GrammarParameter> ",")* =  => Call(ActionFn(128));)
    //
    //   Comma<GrammarParameter> -> S20
    //   (<GrammarParameter> ",")* -> S19
    pub fn __state13<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action128(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cGrammarParameter_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action128(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cGrammarParameter_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cGrammarParameter_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state20(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_28_3cGrammarParameter_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state19(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 14
    //   GrammarParameters? = GrammarParameters (*) [";"]
    //   GrammarParameters? = GrammarParameters (*) ["where"]
    //
    //   "where" -> Reduce(GrammarParameters? = GrammarParameters => Call(ActionFn(115));)
    //   ";" -> Reduce(GrammarParameters? = GrammarParameters => Call(ActionFn(115));)
    //
    pub fn __state14<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Vec<Parameter>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Where(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action115(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarParameters_3f(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action115(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarParameters_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 15
    //   (<TypeParameter> ",") = (*) TypeParameter "," [">"]
    //   (<TypeParameter> ",") = (*) TypeParameter "," ["Id"]
    //   (<TypeParameter> ",") = (*) TypeParameter "," ["Lifetime"]
    //   (<TypeParameter> ",")* = (<TypeParameter> ",")* (*) (<TypeParameter> ",") [">"]
    //   (<TypeParameter> ",")* = (<TypeParameter> ",")* (*) (<TypeParameter> ",") ["Id"]
    //   (<TypeParameter> ",")* = (<TypeParameter> ",")* (*) (<TypeParameter> ",") ["Lifetime"]
    //   Comma<TypeParameter> = (<TypeParameter> ",")* (*) TypeParameter? [">"]
    //   TypeParameter = (*) "Id" [","]
    //   TypeParameter = (*) "Id" [">"]
    //   TypeParameter = (*) "Lifetime" [","]
    //   TypeParameter = (*) "Lifetime" [">"]
    //   TypeParameter? = (*) [">"]
    //   TypeParameter? = (*) TypeParameter [">"]
    //
    //   "Lifetime" -> Shift(S22)
    //   "Id" -> Shift(S21)
    //   ">" -> Reduce(TypeParameter? =  => Call(ActionFn(122));)
    //
    //   TypeParameter? -> S24
    //   TypeParameter -> S23
    //   (<TypeParameter> ",") -> S25
    pub fn __state15<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeParameter>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state22(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state21(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action122(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::TypeParameter_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::TypeParameter_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state24(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::TypeParameter(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state23(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state25(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 16
    //   GrammarTypeParameters = "<" Comma<TypeParameter> (*) ">" ["("]
    //   GrammarTypeParameters = "<" Comma<TypeParameter> (*) ">" [";"]
    //   GrammarTypeParameters = "<" Comma<TypeParameter> (*) ">" ["where"]
    //
    //   ">" -> Shift(S26)
    //
    pub fn __state16<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeParameter>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state26(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 17
    //   Grammar = Use* @L "grammar" @R GrammarTypeParameters? GrammarParameters? "where"? (*) ";" GrammarItem* [EOF]
    //
    //   ";" -> Shift(S27)
    //
    pub fn __state17<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<::std::option::Option<Vec<TypeParameter>>>,
        __sym5: &mut Option<::std::option::Option<Vec<Parameter>>>,
        __sym6: &mut Option<::std::option::Option<Vec<&'input str>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Semi(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym7 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state27(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 18
    //   "where"? = "where" (*) [";"]
    //
    //   ";" -> Reduce("where"? = "where" => Call(ActionFn(113));)
    //
    pub fn __state18<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Vec<&'input str>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action113(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22where_22_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 19
    //   (<GrammarParameter> ",") = (*) GrammarParameter "," [")"]
    //   (<GrammarParameter> ",") = (*) GrammarParameter "," ["Id"]
    //   (<GrammarParameter> ",")* = (<GrammarParameter> ",")* (*) (<GrammarParameter> ",") [")"]
    //   (<GrammarParameter> ",")* = (<GrammarParameter> ",")* (*) (<GrammarParameter> ",") ["Id"]
    //   Comma<GrammarParameter> = (<GrammarParameter> ",")* (*) GrammarParameter? [")"]
    //   GrammarParameter = (*) Id ":" TypeRef [")"]
    //   GrammarParameter = (*) Id ":" TypeRef [","]
    //   GrammarParameter? = (*) [")"]
    //   GrammarParameter? = (*) GrammarParameter [")"]
    //   Id = (*) "Id" [":"]
    //
    //   "Id" -> Shift(S30)
    //   ")" -> Reduce(GrammarParameter? =  => Call(ActionFn(127));)
    //
    //   (<GrammarParameter> ",") -> S31
    //   GrammarParameter -> S28
    //   GrammarParameter? -> S29
    //   Id -> S32
    pub fn __state19<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Parameter>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state30(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action127(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarParameter_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cGrammarParameter_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state31(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::GrammarParameter(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state28(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::GrammarParameter_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state29(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state32(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 20
    //   GrammarParameters = "(" Comma<GrammarParameter> (*) ")" [";"]
    //   GrammarParameters = "(" Comma<GrammarParameter> (*) ")" ["where"]
    //
    //   ")" -> Shift(S33)
    //
    pub fn __state20<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<Parameter>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state33(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 21
    //   TypeParameter = "Id" (*) [","]
    //   TypeParameter = "Id" (*) [">"]
    //
    //   "," -> Reduce(TypeParameter = "Id" => Call(ActionFn(5));)
    //   ">" -> Reduce(TypeParameter = "Id" => Call(ActionFn(5));)
    //
    pub fn __state21<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action5(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeParameter(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action5(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeParameter(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 22
    //   TypeParameter = "Lifetime" (*) [","]
    //   TypeParameter = "Lifetime" (*) [">"]
    //
    //   "," -> Reduce(TypeParameter = "Lifetime" => Call(ActionFn(4));)
    //   ">" -> Reduce(TypeParameter = "Lifetime" => Call(ActionFn(4));)
    //
    pub fn __state22<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action4(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeParameter(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action4(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeParameter(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 23
    //   (<TypeParameter> ",") = TypeParameter (*) "," [">"]
    //   (<TypeParameter> ",") = TypeParameter (*) "," ["Id"]
    //   (<TypeParameter> ",") = TypeParameter (*) "," ["Lifetime"]
    //   TypeParameter? = TypeParameter (*) [">"]
    //
    //   "," -> Shift(S34)
    //   ">" -> Reduce(TypeParameter? = TypeParameter => Call(ActionFn(121));)
    //
    pub fn __state23<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeParameter>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state34(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action121(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeParameter_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 24
    //   Comma<TypeParameter> = (<TypeParameter> ",")* TypeParameter? (*) [">"]
    //
    //   ">" -> Reduce(Comma<TypeParameter> = (<TypeParameter> ",")*, TypeParameter? => Call(ActionFn(110));)
    //
    pub fn __state24<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeParameter>>,
        __sym1: &mut Option<::std::option::Option<TypeParameter>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action110(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cTypeParameter_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 25
    //   (<TypeParameter> ",")* = (<TypeParameter> ",")* (<TypeParameter> ",") (*) [">"]
    //   (<TypeParameter> ",")* = (<TypeParameter> ",")* (<TypeParameter> ",") (*) ["Id"]
    //   (<TypeParameter> ",")* = (<TypeParameter> ",")* (<TypeParameter> ",") (*) ["Lifetime"]
    //
    //   "Lifetime" -> Reduce((<TypeParameter> ",")* = (<TypeParameter> ",")*, (<TypeParameter> ",") => Call(ActionFn(124));)
    //   ">" -> Reduce((<TypeParameter> ",")* = (<TypeParameter> ",")*, (<TypeParameter> ",") => Call(ActionFn(124));)
    //   "Id" -> Reduce((<TypeParameter> ",")* = (<TypeParameter> ",")*, (<TypeParameter> ",") => Call(ActionFn(124));)
    //
    pub fn __state25<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeParameter>>,
        __sym1: &mut Option<TypeParameter>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action124(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action124(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action124(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 26
    //   GrammarTypeParameters = "<" Comma<TypeParameter> ">" (*) ["("]
    //   GrammarTypeParameters = "<" Comma<TypeParameter> ">" (*) [";"]
    //   GrammarTypeParameters = "<" Comma<TypeParameter> ">" (*) ["where"]
    //
    //   ";" -> Reduce(GrammarTypeParameters = "<", Comma<TypeParameter>, ">" => Call(ActionFn(3));)
    //   "(" -> Reduce(GrammarTypeParameters = "<", Comma<TypeParameter>, ">" => Call(ActionFn(3));)
    //   "where" -> Reduce(GrammarTypeParameters = "<", Comma<TypeParameter>, ">" => Call(ActionFn(3));)
    //
    pub fn __state26<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeParameter>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action3(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarTypeParameters(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action3(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarTypeParameters(__nt)));
            }
            Some((_, Tok::Where(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action3(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarTypeParameters(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 27
    //   Grammar = Use* @L "grammar" @R GrammarTypeParameters? GrammarParameters? "where"? ";" (*) GrammarItem* [EOF]
    //   GrammarItem* = (*) [EOF]
    //   GrammarItem* = (*) ["Escape"]
    //   GrammarItem* = (*) ["Id"]
    //   GrammarItem* = (*) ["MacroId"]
    //   GrammarItem* = (*) ["extern"]
    //   GrammarItem* = (*) ["pub"]
    //   GrammarItem* = (*) ["use"]
    //   GrammarItem* = (*) GrammarItem* GrammarItem [EOF]
    //   GrammarItem* = (*) GrammarItem* GrammarItem ["Escape"]
    //   GrammarItem* = (*) GrammarItem* GrammarItem ["Id"]
    //   GrammarItem* = (*) GrammarItem* GrammarItem ["MacroId"]
    //   GrammarItem* = (*) GrammarItem* GrammarItem ["extern"]
    //   GrammarItem* = (*) GrammarItem* GrammarItem ["pub"]
    //   GrammarItem* = (*) GrammarItem* GrammarItem ["use"]
    //
    //   "Escape" -> Reduce(GrammarItem* =  => Call(ActionFn(111));)
    //   "MacroId" -> Reduce(GrammarItem* =  => Call(ActionFn(111));)
    //   "Id" -> Reduce(GrammarItem* =  => Call(ActionFn(111));)
    //   "pub" -> Reduce(GrammarItem* =  => Call(ActionFn(111));)
    //   EOF -> Reduce(GrammarItem* =  => Call(ActionFn(111));)
    //   "use" -> Reduce(GrammarItem* =  => Call(ActionFn(111));)
    //   "extern" -> Reduce(GrammarItem* =  => Call(ActionFn(111));)
    //
    //   GrammarItem* -> S35
    pub fn __state27<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<::std::option::Option<Vec<TypeParameter>>>,
        __sym5: &mut Option<::std::option::Option<Vec<Parameter>>>,
        __sym6: &mut Option<::std::option::Option<Vec<&'input str>>>,
        __sym7: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action111(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action111(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action111(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __nt = super::__action111(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt));
            }
            None => {
                let __nt = super::__action111(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt));
            }
            Some((_, Tok::Use(_), _)) => {
                let __nt = super::__action111(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __nt = super::__action111(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym7.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::GrammarItem_2a(__nt) => {
                    let __sym8 = &mut Some(__nt);
                    __result = try!(__state35(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 28
    //   (<GrammarParameter> ",") = GrammarParameter (*) "," [")"]
    //   (<GrammarParameter> ",") = GrammarParameter (*) "," ["Id"]
    //   GrammarParameter? = GrammarParameter (*) [")"]
    //
    //   ")" -> Reduce(GrammarParameter? = GrammarParameter => Call(ActionFn(126));)
    //   "," -> Shift(S36)
    //
    pub fn __state28<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Parameter>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state36(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action126(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarParameter_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 29
    //   Comma<GrammarParameter> = (<GrammarParameter> ",")* GrammarParameter? (*) [")"]
    //
    //   ")" -> Reduce(Comma<GrammarParameter> = (<GrammarParameter> ",")*, GrammarParameter? => Call(ActionFn(109));)
    //
    pub fn __state29<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Parameter>>,
        __sym1: &mut Option<::std::option::Option<Parameter>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action109(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cGrammarParameter_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 30
    //   Id = "Id" (*) [":"]
    //
    //   ":" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state30<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Colon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 31
    //   (<GrammarParameter> ",")* = (<GrammarParameter> ",")* (<GrammarParameter> ",") (*) [")"]
    //   (<GrammarParameter> ",")* = (<GrammarParameter> ",")* (<GrammarParameter> ",") (*) ["Id"]
    //
    //   "Id" -> Reduce((<GrammarParameter> ",")* = (<GrammarParameter> ",")*, (<GrammarParameter> ",") => Call(ActionFn(129));)
    //   ")" -> Reduce((<GrammarParameter> ",")* = (<GrammarParameter> ",")*, (<GrammarParameter> ",") => Call(ActionFn(129));)
    //
    pub fn __state31<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Parameter>>,
        __sym1: &mut Option<Parameter>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action129(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cGrammarParameter_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action129(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cGrammarParameter_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 32
    //   GrammarParameter = Id (*) ":" TypeRef [")"]
    //   GrammarParameter = Id (*) ":" TypeRef [","]
    //
    //   ":" -> Shift(S37)
    //
    pub fn __state32<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Colon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state37(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 33
    //   GrammarParameters = "(" Comma<GrammarParameter> ")" (*) [";"]
    //   GrammarParameters = "(" Comma<GrammarParameter> ")" (*) ["where"]
    //
    //   "where" -> Reduce(GrammarParameters = "(", Comma<GrammarParameter>, ")" => Call(ActionFn(6));)
    //   ";" -> Reduce(GrammarParameters = "(", Comma<GrammarParameter>, ")" => Call(ActionFn(6));)
    //
    pub fn __state33<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<Parameter>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Where(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action6(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarParameters(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action6(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarParameters(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 34
    //   (<TypeParameter> ",") = TypeParameter "," (*) [">"]
    //   (<TypeParameter> ",") = TypeParameter "," (*) ["Id"]
    //   (<TypeParameter> ",") = TypeParameter "," (*) ["Lifetime"]
    //
    //   "Lifetime" -> Reduce((<TypeParameter> ",") = TypeParameter, "," => Call(ActionFn(125));)
    //   ">" -> Reduce((<TypeParameter> ",") = TypeParameter, "," => Call(ActionFn(125));)
    //   "Id" -> Reduce((<TypeParameter> ",") = TypeParameter, "," => Call(ActionFn(125));)
    //
    pub fn __state34<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeParameter>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action125(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action125(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action125(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeParameter_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 35
    //   "pub"? = (*) ["Escape"]
    //   "pub"? = (*) ["Id"]
    //   "pub"? = (*) ["MacroId"]
    //   "pub"? = (*) "pub" ["Escape"]
    //   "pub"? = (*) "pub" ["Id"]
    //   "pub"? = (*) "pub" ["MacroId"]
    //   @L = (*) ["extern"]
    //   ExternToken = (*) @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = (*) @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = (*) @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = (*) @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = (*) @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = (*) @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = (*) @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //   Grammar = Use* @L "grammar" @R GrammarTypeParameters? GrammarParameters? "where"? ";" GrammarItem* (*) [EOF]
    //   GrammarItem = (*) ExternToken [EOF]
    //   GrammarItem = (*) ExternToken ["Escape"]
    //   GrammarItem = (*) ExternToken ["Id"]
    //   GrammarItem = (*) ExternToken ["MacroId"]
    //   GrammarItem = (*) ExternToken ["extern"]
    //   GrammarItem = (*) ExternToken ["pub"]
    //   GrammarItem = (*) ExternToken ["use"]
    //   GrammarItem = (*) Nonterminal [EOF]
    //   GrammarItem = (*) Nonterminal ["Escape"]
    //   GrammarItem = (*) Nonterminal ["Id"]
    //   GrammarItem = (*) Nonterminal ["MacroId"]
    //   GrammarItem = (*) Nonterminal ["extern"]
    //   GrammarItem = (*) Nonterminal ["pub"]
    //   GrammarItem = (*) Nonterminal ["use"]
    //   GrammarItem = (*) Use [EOF]
    //   GrammarItem = (*) Use ["Escape"]
    //   GrammarItem = (*) Use ["Id"]
    //   GrammarItem = (*) Use ["MacroId"]
    //   GrammarItem = (*) Use ["extern"]
    //   GrammarItem = (*) Use ["pub"]
    //   GrammarItem = (*) Use ["use"]
    //   GrammarItem* = GrammarItem* (*) GrammarItem [EOF]
    //   GrammarItem* = GrammarItem* (*) GrammarItem ["Escape"]
    //   GrammarItem* = GrammarItem* (*) GrammarItem ["Id"]
    //   GrammarItem* = GrammarItem* (*) GrammarItem ["MacroId"]
    //   GrammarItem* = GrammarItem* (*) GrammarItem ["extern"]
    //   GrammarItem* = GrammarItem* (*) GrammarItem ["pub"]
    //   GrammarItem* = GrammarItem* (*) GrammarItem ["use"]
    //   Nonterminal = (*) "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives [EOF]
    //   Nonterminal = (*) "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["Escape"]
    //   Nonterminal = (*) "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["Id"]
    //   Nonterminal = (*) "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["MacroId"]
    //   Nonterminal = (*) "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["extern"]
    //   Nonterminal = (*) "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["pub"]
    //   Nonterminal = (*) "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["use"]
    //   Use = (*) "use" ";" [EOF]
    //   Use = (*) "use" ";" ["Escape"]
    //   Use = (*) "use" ";" ["Id"]
    //   Use = (*) "use" ";" ["MacroId"]
    //   Use = (*) "use" ";" ["extern"]
    //   Use = (*) "use" ";" ["pub"]
    //   Use = (*) "use" ";" ["use"]
    //
    //   "Id" -> Reduce("pub"? =  => Call(ActionFn(108));)
    //   "extern" -> Reduce(@L =  => Lookahead;)
    //   "use" -> Shift(S40)
    //   EOF -> Reduce(Grammar = Use*, @L, "grammar", @R, GrammarTypeParameters?, GrammarParameters?, "where"?, ";", GrammarItem* => Call(ActionFn(2));)
    //   "pub" -> Shift(S41)
    //   "MacroId" -> Reduce("pub"? =  => Call(ActionFn(108));)
    //   "Escape" -> Reduce("pub"? =  => Call(ActionFn(108));)
    //
    //   ExternToken -> S38
    //   GrammarItem -> S45
    //   Nonterminal -> S42
    //   "pub"? -> S39
    //   Use -> S44
    //   @L -> S43
    pub fn __state35<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<::std::option::Option<Vec<TypeParameter>>>,
        __sym5: &mut Option<::std::option::Option<Vec<Parameter>>>,
        __sym6: &mut Option<::std::option::Option<Vec<&'input str>>>,
        __sym7: &mut Option<Tok<'input>>,
        __sym8: &mut Option<::std::vec::Vec<GrammarItem>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Use(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym9 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state40(text, __lookbehind, __lookahead, __tokens, __sym9));
            }
            Some((_, __tok @ Tok::Pub(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym9 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state41(text, __lookbehind, __lookahead, __tokens, __sym9));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action108(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22pub_22_3f(__nt));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __sym8 = __sym8.take().unwrap();
                let __nt = super::__action2(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Grammar(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action108(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22pub_22_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action108(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22pub_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym8.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::ExternToken(__nt) => {
                    let __sym9 = &mut Some(__nt);
                    __result = try!(__state38(text, __lookbehind, __lookahead, __tokens, __sym9));
                }
                __Nonterminal::GrammarItem(__nt) => {
                    let __sym9 = &mut Some(__nt);
                    __result = try!(__state45(text, __lookbehind, __lookahead, __tokens, __sym8, __sym9));
                }
                __Nonterminal::Nonterminal(__nt) => {
                    let __sym9 = &mut Some(__nt);
                    __result = try!(__state42(text, __lookbehind, __lookahead, __tokens, __sym9));
                }
                __Nonterminal::_22pub_22_3f(__nt) => {
                    let __sym9 = &mut Some(__nt);
                    __result = try!(__state39(text, __lookbehind, __lookahead, __tokens, __sym9));
                }
                __Nonterminal::Use(__nt) => {
                    let __sym9 = &mut Some(__nt);
                    __result = try!(__state44(text, __lookbehind, __lookahead, __tokens, __sym9));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym9 = &mut Some(__nt);
                    __result = try!(__state43(text, __lookbehind, __lookahead, __tokens, __sym9));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 36
    //   (<GrammarParameter> ",") = GrammarParameter "," (*) [")"]
    //   (<GrammarParameter> ",") = GrammarParameter "," (*) ["Id"]
    //
    //   ")" -> Reduce((<GrammarParameter> ",") = GrammarParameter, "," => Call(ActionFn(130));)
    //   "Id" -> Reduce((<GrammarParameter> ",") = GrammarParameter, "," => Call(ActionFn(130));)
    //
    pub fn __state36<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Parameter>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action130(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cGrammarParameter_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action130(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cGrammarParameter_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 37
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [")"]
    //   Escape = (*) "Escape" [","]
    //   GrammarParameter = Id ":" (*) TypeRef [")"]
    //   GrammarParameter = Id ":" (*) TypeRef [","]
    //   Path = (*) "::"? (<Id> "::")* Id [")"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   TypeRef = (*) Escape [")"]
    //   TypeRef = (*) Escape [","]
    //   TypeRef = (*) Path [")"]
    //   TypeRef = (*) Path [","]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [")"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [")"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [","]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [")"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [","]
    //
    //   "::" -> Shift(S50)
    //   "&" -> Shift(S46)
    //   "(" -> Shift(S47)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "Escape" -> Shift(S53)
    //
    //   Path -> S52
    //   Escape -> S49
    //   "::"? -> S48
    //   TypeRef -> S51
    pub fn __state37<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state46(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state47(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state53(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Path(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state52(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state49(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state48(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state51(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 38
    //   GrammarItem = ExternToken (*) [EOF]
    //   GrammarItem = ExternToken (*) ["Escape"]
    //   GrammarItem = ExternToken (*) ["Id"]
    //   GrammarItem = ExternToken (*) ["MacroId"]
    //   GrammarItem = ExternToken (*) ["extern"]
    //   GrammarItem = ExternToken (*) ["pub"]
    //   GrammarItem = ExternToken (*) ["use"]
    //
    //   "extern" -> Reduce(GrammarItem = ExternToken => Call(ActionFn(9));)
    //   "MacroId" -> Reduce(GrammarItem = ExternToken => Call(ActionFn(9));)
    //   "pub" -> Reduce(GrammarItem = ExternToken => Call(ActionFn(9));)
    //   EOF -> Reduce(GrammarItem = ExternToken => Call(ActionFn(9));)
    //   "Id" -> Reduce(GrammarItem = ExternToken => Call(ActionFn(9));)
    //   "use" -> Reduce(GrammarItem = ExternToken => Call(ActionFn(9));)
    //   "Escape" -> Reduce(GrammarItem = ExternToken => Call(ActionFn(9));)
    //
    pub fn __state38<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<GrammarItem>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action9(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action9(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action9(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action9(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action9(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action9(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action9(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 39
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   Nonterminal = "pub"? (*) @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives [EOF]
    //   Nonterminal = "pub"? (*) @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["Escape"]
    //   Nonterminal = "pub"? (*) @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["Id"]
    //   Nonterminal = "pub"? (*) @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["MacroId"]
    //   Nonterminal = "pub"? (*) @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["extern"]
    //   Nonterminal = "pub"? (*) @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["pub"]
    //   Nonterminal = "pub"? (*) @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["use"]
    //
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //
    //   @L -> S54
    pub fn __state39<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state54(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 40
    //   Use = "use" (*) ";" [EOF]
    //   Use = "use" (*) ";" ["Escape"]
    //   Use = "use" (*) ";" ["Id"]
    //   Use = "use" (*) ";" ["MacroId"]
    //   Use = "use" (*) ";" ["extern"]
    //   Use = "use" (*) ";" ["pub"]
    //   Use = "use" (*) ";" ["use"]
    //
    //   ";" -> Shift(S55)
    //
    pub fn __state40<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Semi(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state55(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 41
    //   "pub"? = "pub" (*) ["Escape"]
    //   "pub"? = "pub" (*) ["Id"]
    //   "pub"? = "pub" (*) ["MacroId"]
    //
    //   "MacroId" -> Reduce("pub"? = "pub" => Call(ActionFn(107));)
    //   "Escape" -> Reduce("pub"? = "pub" => Call(ActionFn(107));)
    //   "Id" -> Reduce("pub"? = "pub" => Call(ActionFn(107));)
    //
    pub fn __state41<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action107(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22pub_22_3f(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action107(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22pub_22_3f(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action107(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22pub_22_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 42
    //   GrammarItem = Nonterminal (*) [EOF]
    //   GrammarItem = Nonterminal (*) ["Escape"]
    //   GrammarItem = Nonterminal (*) ["Id"]
    //   GrammarItem = Nonterminal (*) ["MacroId"]
    //   GrammarItem = Nonterminal (*) ["extern"]
    //   GrammarItem = Nonterminal (*) ["pub"]
    //   GrammarItem = Nonterminal (*) ["use"]
    //
    //   "MacroId" -> Reduce(GrammarItem = Nonterminal => Call(ActionFn(10));)
    //   "extern" -> Reduce(GrammarItem = Nonterminal => Call(ActionFn(10));)
    //   EOF -> Reduce(GrammarItem = Nonterminal => Call(ActionFn(10));)
    //   "pub" -> Reduce(GrammarItem = Nonterminal => Call(ActionFn(10));)
    //   "Escape" -> Reduce(GrammarItem = Nonterminal => Call(ActionFn(10));)
    //   "use" -> Reduce(GrammarItem = Nonterminal => Call(ActionFn(10));)
    //   "Id" -> Reduce(GrammarItem = Nonterminal => Call(ActionFn(10));)
    //
    pub fn __state42<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<GrammarItem>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action10(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action10(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action10(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action10(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action10(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action10(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action10(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 43
    //   ExternToken = @L (*) "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L (*) "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L (*) "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L (*) "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L (*) "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L (*) "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L (*) "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "extern" -> Shift(S56)
    //
    pub fn __state43<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Extern(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state56(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 44
    //   GrammarItem = Use (*) [EOF]
    //   GrammarItem = Use (*) ["Escape"]
    //   GrammarItem = Use (*) ["Id"]
    //   GrammarItem = Use (*) ["MacroId"]
    //   GrammarItem = Use (*) ["extern"]
    //   GrammarItem = Use (*) ["pub"]
    //   GrammarItem = Use (*) ["use"]
    //
    //   EOF -> Reduce(GrammarItem = Use => Call(ActionFn(8));)
    //   "Escape" -> Reduce(GrammarItem = Use => Call(ActionFn(8));)
    //   "MacroId" -> Reduce(GrammarItem = Use => Call(ActionFn(8));)
    //   "use" -> Reduce(GrammarItem = Use => Call(ActionFn(8));)
    //   "extern" -> Reduce(GrammarItem = Use => Call(ActionFn(8));)
    //   "Id" -> Reduce(GrammarItem = Use => Call(ActionFn(8));)
    //   "pub" -> Reduce(GrammarItem = Use => Call(ActionFn(8));)
    //
    pub fn __state44<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<GrammarItem>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action8(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action8(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action8(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action8(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action8(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action8(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action8(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 45
    //   GrammarItem* = GrammarItem* GrammarItem (*) [EOF]
    //   GrammarItem* = GrammarItem* GrammarItem (*) ["Escape"]
    //   GrammarItem* = GrammarItem* GrammarItem (*) ["Id"]
    //   GrammarItem* = GrammarItem* GrammarItem (*) ["MacroId"]
    //   GrammarItem* = GrammarItem* GrammarItem (*) ["extern"]
    //   GrammarItem* = GrammarItem* GrammarItem (*) ["pub"]
    //   GrammarItem* = GrammarItem* GrammarItem (*) ["use"]
    //
    //   "MacroId" -> Reduce(GrammarItem* = GrammarItem*, GrammarItem => Call(ActionFn(112));)
    //   EOF -> Reduce(GrammarItem* = GrammarItem*, GrammarItem => Call(ActionFn(112));)
    //   "pub" -> Reduce(GrammarItem* = GrammarItem*, GrammarItem => Call(ActionFn(112));)
    //   "use" -> Reduce(GrammarItem* = GrammarItem*, GrammarItem => Call(ActionFn(112));)
    //   "Escape" -> Reduce(GrammarItem* = GrammarItem*, GrammarItem => Call(ActionFn(112));)
    //   "Id" -> Reduce(GrammarItem* = GrammarItem*, GrammarItem => Call(ActionFn(112));)
    //   "extern" -> Reduce(GrammarItem* = GrammarItem*, GrammarItem => Call(ActionFn(112));)
    //
    pub fn __state45<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<GrammarItem>>,
        __sym1: &mut Option<GrammarItem>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action112(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt)));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action112(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt)));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action112(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action112(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action112(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action112(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt)));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action112(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarItem_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 46
    //   Lifetime = (*) "Lifetime" ["&"]
    //   Lifetime = (*) "Lifetime" ["("]
    //   Lifetime = (*) "Lifetime" ["::"]
    //   Lifetime = (*) "Lifetime" ["Escape"]
    //   Lifetime = (*) "Lifetime" ["Id"]
    //   Lifetime = (*) "Lifetime" ["mut"]
    //   Lifetime? = (*) ["&"]
    //   Lifetime? = (*) ["("]
    //   Lifetime? = (*) ["::"]
    //   Lifetime? = (*) ["Escape"]
    //   Lifetime? = (*) ["Id"]
    //   Lifetime? = (*) ["mut"]
    //   Lifetime? = (*) Lifetime ["&"]
    //   Lifetime? = (*) Lifetime ["("]
    //   Lifetime? = (*) Lifetime ["::"]
    //   Lifetime? = (*) Lifetime ["Escape"]
    //   Lifetime? = (*) Lifetime ["Id"]
    //   Lifetime? = (*) Lifetime ["mut"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [")"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [","]
    //
    //   "mut" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "::" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Lifetime" -> Shift(S58)
    //   "(" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Id" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Escape" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "&" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //
    //   Lifetime? -> S57
    //   Lifetime -> S59
    pub fn __state46<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state58(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Lifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state57(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state59(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 47
    //   (<TypeRef> ",")* = (*) ["&"]
    //   (<TypeRef> ",")* = (*) ["("]
    //   (<TypeRef> ",")* = (*) [")"]
    //   (<TypeRef> ",")* = (*) ["::"]
    //   (<TypeRef> ",")* = (*) ["Escape"]
    //   (<TypeRef> ",")* = (*) ["Id"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (*) (<TypeRef> ",")* TypeRef? [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [","]
    //
    //   "Escape" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   ")" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "::" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "&" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Id" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "(" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //
    //   (<TypeRef> ",")* -> S60
    //   Comma<TypeRef> -> S61
    pub fn __state47<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state60(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Comma_3cTypeRef_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state61(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 48
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id [")"]
    //   Path = "::"? (*) (<Id> "::")* Id [","]
    //   Path = "::"? (*) (<Id> "::")* Id ["<"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S62
    pub fn __state48<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state62(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 49
    //   TypeRef = Escape (*) [")"]
    //   TypeRef = Escape (*) [","]
    //
    //   ")" -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //   "," -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //
    pub fn __state49<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 50
    //   "::"? = "::" (*) ["Id"]
    //
    //   "Id" -> Reduce("::"? = "::" => Call(ActionFn(85));)
    //
    pub fn __state50<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action85(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 51
    //   GrammarParameter = Id ":" TypeRef (*) [")"]
    //   GrammarParameter = Id ":" TypeRef (*) [","]
    //
    //   "," -> Reduce(GrammarParameter = Id, ":", TypeRef => Call(ActionFn(7));)
    //   ")" -> Reduce(GrammarParameter = Id, ":", TypeRef => Call(ActionFn(7));)
    //
    pub fn __state51<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action7(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarParameter(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action7(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::GrammarParameter(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 52
    //   TypeRef = Path (*) [")"]
    //   TypeRef = Path (*) [","]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [")"]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [","]
    //
    //   ")" -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //   "<" -> Shift(S63)
    //   "," -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //
    pub fn __state52<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state63(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 53
    //   Escape = "Escape" (*) [")"]
    //   Escape = "Escape" (*) [","]
    //
    //   ")" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "," -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state53<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 54
    //   Id = (*) "Id" [":"]
    //   Id = (*) "Id" ["="]
    //   MacroId = (*) "MacroId" ["<"]
    //   Nonterminal = "pub"? @L (*) NonterminalName @R (":" <TypeRef>)? "=" Alternatives [EOF]
    //   Nonterminal = "pub"? @L (*) NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["Escape"]
    //   Nonterminal = "pub"? @L (*) NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["Id"]
    //   Nonterminal = "pub"? @L (*) NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["MacroId"]
    //   Nonterminal = "pub"? @L (*) NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["extern"]
    //   Nonterminal = "pub"? @L (*) NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["pub"]
    //   Nonterminal = "pub"? @L (*) NonterminalName @R (":" <TypeRef>)? "=" Alternatives ["use"]
    //   NonterminalId = (*) Id [":"]
    //   NonterminalId = (*) Id ["="]
    //   NonterminalName = (*) MacroId "<" Comma<NonterminalId> ">" [":"]
    //   NonterminalName = (*) MacroId "<" Comma<NonterminalId> ">" ["="]
    //   NonterminalName = (*) NonterminalId [":"]
    //   NonterminalName = (*) NonterminalId ["="]
    //   NonterminalName = (*) "Escape" [":"]
    //   NonterminalName = (*) "Escape" ["="]
    //
    //   "Escape" -> Shift(S67)
    //   "MacroId" -> Shift(S68)
    //   "Id" -> Shift(S66)
    //
    //   NonterminalName -> S70
    //   NonterminalId -> S65
    //   Id -> S69
    //   MacroId -> S64
    pub fn __state54<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state67(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::MacroId(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state66(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::NonterminalName(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state70(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state65(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state69(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::MacroId(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state64(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 55
    //   Use = "use" ";" (*) [EOF]
    //   Use = "use" ";" (*) ["Escape"]
    //   Use = "use" ";" (*) ["Id"]
    //   Use = "use" ";" (*) ["MacroId"]
    //   Use = "use" ";" (*) ["extern"]
    //   Use = "use" ";" (*) ["pub"]
    //   Use = "use" ";" (*) ["use"]
    //
    //   EOF -> Reduce(Use = "use", ";" => Call(ActionFn(11));)
    //   "Id" -> Reduce(Use = "use", ";" => Call(ActionFn(11));)
    //   "Escape" -> Reduce(Use = "use", ";" => Call(ActionFn(11));)
    //   "MacroId" -> Reduce(Use = "use", ";" => Call(ActionFn(11));)
    //   "extern" -> Reduce(Use = "use", ";" => Call(ActionFn(11));)
    //   "use" -> Reduce(Use = "use", ";" => Call(ActionFn(11));)
    //   "pub" -> Reduce(Use = "use", ";" => Call(ActionFn(11));)
    //
    pub fn __state55<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action11(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action11(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action11(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action11(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use(__nt)));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action11(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action11(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use(__nt)));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action11(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Use(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 56
    //   ExternToken = @L "extern" (*) "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" (*) "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" (*) "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" (*) "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" (*) "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" (*) "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" (*) "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "token" -> Shift(S71)
    //
    pub fn __state56<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Token(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state71(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 57
    //   "mut"? = (*) ["&"]
    //   "mut"? = (*) ["("]
    //   "mut"? = (*) ["::"]
    //   "mut"? = (*) ["Escape"]
    //   "mut"? = (*) ["Id"]
    //   "mut"? = (*) "mut" ["&"]
    //   "mut"? = (*) "mut" ["("]
    //   "mut"? = (*) "mut" ["::"]
    //   "mut"? = (*) "mut" ["Escape"]
    //   "mut"? = (*) "mut" ["Id"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [")"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [","]
    //
    //   "Id" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "(" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "Escape" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "mut" -> Shift(S73)
    //   "::" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "&" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //
    //   "mut"? -> S72
    pub fn __state57<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Mut(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state73(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22mut_22_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state72(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 58
    //   Lifetime = "Lifetime" (*) ["&"]
    //   Lifetime = "Lifetime" (*) ["("]
    //   Lifetime = "Lifetime" (*) ["::"]
    //   Lifetime = "Lifetime" (*) ["Escape"]
    //   Lifetime = "Lifetime" (*) ["Id"]
    //   Lifetime = "Lifetime" (*) ["mut"]
    //
    //   "&" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "Id" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "Escape" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "(" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "mut" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "::" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //
    pub fn __state58<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 59
    //   Lifetime? = Lifetime (*) ["&"]
    //   Lifetime? = Lifetime (*) ["("]
    //   Lifetime? = Lifetime (*) ["::"]
    //   Lifetime? = Lifetime (*) ["Escape"]
    //   Lifetime? = Lifetime (*) ["Id"]
    //   Lifetime? = Lifetime (*) ["mut"]
    //
    //   "::" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "&" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "mut" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "Escape" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "Id" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "(" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //
    pub fn __state59<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 60
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["&"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["("]
    //   (<TypeRef> ",") = (*) TypeRef "," [")"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["::"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["Escape"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["Id"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (<TypeRef> ",")* (*) TypeRef? [")"]
    //   Escape = (*) "Escape" [")"]
    //   Escape = (*) "Escape" [","]
    //   Path = (*) "::"? (<Id> "::")* Id [")"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   TypeRef = (*) Escape [")"]
    //   TypeRef = (*) Escape [","]
    //   TypeRef = (*) Path [")"]
    //   TypeRef = (*) Path [","]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [")"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [")"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [","]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [")"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [","]
    //   TypeRef? = (*) [")"]
    //   TypeRef? = (*) TypeRef [")"]
    //
    //   "&" -> Shift(S46)
    //   "::" -> Shift(S50)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   ")" -> Reduce(TypeRef? =  => Call(ActionFn(142));)
    //   "Escape" -> Shift(S53)
    //   "(" -> Shift(S47)
    //
    //   TypeRef? -> S75
    //   TypeRef -> S76
    //   Path -> S52
    //   "::"? -> S48
    //   Escape -> S49
    //   (<TypeRef> ",") -> S74
    pub fn __state60<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state46(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state53(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state47(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action142(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::TypeRef_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::TypeRef_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state75(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state76(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state52(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state48(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state49(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state74(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 61
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [")"]
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [","]
    //
    //   ")" -> Shift(S77)
    //
    pub fn __state61<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state77(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 62
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" [")"]
    //   Id = (*) "Id" [","]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["<"]
    //   Path = "::"? (<Id> "::")* (*) Id [")"]
    //   Path = "::"? (<Id> "::")* (*) Id [","]
    //   Path = "::"? (<Id> "::")* (*) Id ["<"]
    //
    //   "Id" -> Shift(S79)
    //
    //   Id -> S78
    //   (<Id> "::") -> S80
    pub fn __state62<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state79(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state78(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state80(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 63
    //   (<TypeRefOrLifetime> ",")* = (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (*) (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? [">"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [")"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [","]
    //
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //
    //   Comma<TypeRefOrLifetime> -> S82
    //   (<TypeRefOrLifetime> ",")* -> S81
    pub fn __state63<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state82(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state81(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 64
    //   NonterminalName = MacroId (*) "<" Comma<NonterminalId> ">" [":"]
    //   NonterminalName = MacroId (*) "<" Comma<NonterminalId> ">" ["="]
    //
    //   "<" -> Shift(S83)
    //
    pub fn __state64<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state83(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 65
    //   NonterminalName = NonterminalId (*) [":"]
    //   NonterminalName = NonterminalId (*) ["="]
    //
    //   ":" -> Reduce(NonterminalName = NonterminalId => Call(ActionFn(14));)
    //   "=" -> Reduce(NonterminalName = NonterminalId => Call(ActionFn(14));)
    //
    pub fn __state65<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Colon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action14(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalName(__nt)));
            }
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action14(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalName(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 66
    //   Id = "Id" (*) [":"]
    //   Id = "Id" (*) ["="]
    //
    //   "=" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   ":" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state66<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Colon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 67
    //   NonterminalName = "Escape" (*) [":"]
    //   NonterminalName = "Escape" (*) ["="]
    //
    //   ":" -> Reduce(NonterminalName = "Escape" => Call(ActionFn(15));)
    //   "=" -> Reduce(NonterminalName = "Escape" => Call(ActionFn(15));)
    //
    pub fn __state67<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Colon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action15(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalName(__nt)));
            }
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action15(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalName(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 68
    //   MacroId = "MacroId" (*) ["<"]
    //
    //   "<" -> Reduce(MacroId = "MacroId" => Call(ActionFn(66));)
    //
    pub fn __state68<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action66(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::MacroId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 69
    //   NonterminalId = Id (*) [":"]
    //   NonterminalId = Id (*) ["="]
    //
    //   ":" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "=" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //
    pub fn __state69<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Colon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 70
    //   @R = (*) [":"]
    //   @R = (*) ["="]
    //   Nonterminal = "pub"? @L NonterminalName (*) @R (":" <TypeRef>)? "=" Alternatives [EOF]
    //   Nonterminal = "pub"? @L NonterminalName (*) @R (":" <TypeRef>)? "=" Alternatives ["Escape"]
    //   Nonterminal = "pub"? @L NonterminalName (*) @R (":" <TypeRef>)? "=" Alternatives ["Id"]
    //   Nonterminal = "pub"? @L NonterminalName (*) @R (":" <TypeRef>)? "=" Alternatives ["MacroId"]
    //   Nonterminal = "pub"? @L NonterminalName (*) @R (":" <TypeRef>)? "=" Alternatives ["extern"]
    //   Nonterminal = "pub"? @L NonterminalName (*) @R (":" <TypeRef>)? "=" Alternatives ["pub"]
    //   Nonterminal = "pub"? @L NonterminalName (*) @R (":" <TypeRef>)? "=" Alternatives ["use"]
    //
    //   "=" -> Reduce(@R =  => Lookbehind;)
    //   ":" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S84
    pub fn __state70<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<(NonterminalString, Vec<NonterminalString>)>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Colon(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state84(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 71
    //   @R = (*) ["{"]
    //   ExternToken = @L "extern" "token" (*) @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" (*) @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" (*) @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" (*) @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" (*) @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" (*) @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" (*) @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "{" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S85
    pub fn __state71<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftBrace(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state85(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 72
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [")"]
    //   Escape = (*) "Escape" [","]
    //   Path = (*) "::"? (<Id> "::")* Id [")"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   TypeRef = (*) Escape [")"]
    //   TypeRef = (*) Escape [","]
    //   TypeRef = (*) Path [")"]
    //   TypeRef = (*) Path [","]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [")"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [")"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [","]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [")"]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [","]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [")"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [","]
    //
    //   "::" -> Shift(S50)
    //   "(" -> Shift(S47)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "Escape" -> Shift(S53)
    //   "&" -> Shift(S46)
    //
    //   Escape -> S49
    //   TypeRef -> S86
    //   Path -> S52
    //   "::"? -> S48
    pub fn __state72<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state47(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state53(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state46(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state49(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state86(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state52(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state48(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 73
    //   "mut"? = "mut" (*) ["&"]
    //   "mut"? = "mut" (*) ["("]
    //   "mut"? = "mut" (*) ["::"]
    //   "mut"? = "mut" (*) ["Escape"]
    //   "mut"? = "mut" (*) ["Id"]
    //
    //   "&" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //   "Id" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //   "::" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //   "Escape" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //   "(" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //
    pub fn __state73<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 74
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["&"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["("]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) [")"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["::"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["Escape"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["Id"]
    //
    //   ")" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   "Escape" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   "Id" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   "&" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   "(" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   "::" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //
    pub fn __state74<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
        __sym1: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 75
    //   Comma<TypeRef> = (<TypeRef> ",")* TypeRef? (*) [")"]
    //
    //   ")" -> Reduce(Comma<TypeRef> = (<TypeRef> ",")*, TypeRef? => Call(ActionFn(92));)
    //
    pub fn __state75<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
        __sym1: &mut Option<::std::option::Option<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action92(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cTypeRef_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 76
    //   (<TypeRef> ",") = TypeRef (*) "," ["&"]
    //   (<TypeRef> ",") = TypeRef (*) "," ["("]
    //   (<TypeRef> ",") = TypeRef (*) "," [")"]
    //   (<TypeRef> ",") = TypeRef (*) "," ["::"]
    //   (<TypeRef> ",") = TypeRef (*) "," ["Escape"]
    //   (<TypeRef> ",") = TypeRef (*) "," ["Id"]
    //   TypeRef? = TypeRef (*) [")"]
    //
    //   ")" -> Reduce(TypeRef? = TypeRef => Call(ActionFn(141));)
    //   "," -> Shift(S87)
    //
    pub fn __state76<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state87(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action141(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 77
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [")"]
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [","]
    //
    //   "," -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //   ")" -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //
    pub fn __state77<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 78
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) [")"]
    //   Path = "::"? (<Id> "::")* Id (*) [","]
    //   Path = "::"? (<Id> "::")* Id (*) ["<"]
    //
    //   "," -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   ")" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S88)
    //   "<" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //
    pub fn __state78<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state88(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 79
    //   Id = "Id" (*) [")"]
    //   Id = "Id" (*) [","]
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["<"]
    //
    //   "," -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   ")" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state79<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 80
    //   (<Id> "::")* = (<Id> "::")* (<Id> "::") (*) ["Id"]
    //
    //   "Id" -> Reduce((<Id> "::")* = (<Id> "::")*, (<Id> "::") => Call(ActionFn(83));)
    //
    pub fn __state80<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<InternedString>>,
        __sym1: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action83(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 81
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["&"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["("]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["::"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," [">"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["Escape"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["Id"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (<TypeRefOrLifetime> ",")* (*) TypeRefOrLifetime? [">"]
    //   Escape = (*) "Escape" [","]
    //   Escape = (*) "Escape" [">"]
    //   Lifetime = (*) "Lifetime" [","]
    //   Lifetime = (*) "Lifetime" [">"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id [">"]
    //   TypeRef = (*) Escape [","]
    //   TypeRef = (*) Escape [">"]
    //   TypeRef = (*) Path [","]
    //   TypeRef = (*) Path [">"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [">"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [","]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [">"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [","]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [">"]
    //   TypeRefOrLifetime = (*) Lifetime [","]
    //   TypeRefOrLifetime = (*) Lifetime [">"]
    //   TypeRefOrLifetime = (*) TypeRef [","]
    //   TypeRefOrLifetime = (*) TypeRef [">"]
    //   TypeRefOrLifetime? = (*) [">"]
    //   TypeRefOrLifetime? = (*) TypeRefOrLifetime [">"]
    //
    //   "Escape" -> Shift(S93)
    //   "::" -> Shift(S50)
    //   "Lifetime" -> Shift(S95)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "&" -> Shift(S100)
    //   "(" -> Shift(S94)
    //   ">" -> Reduce(TypeRefOrLifetime? =  => Call(ActionFn(147));)
    //
    //   (<TypeRefOrLifetime> ",") -> S92
    //   TypeRef -> S98
    //   Escape -> S99
    //   "::"? -> S89
    //   Path -> S90
    //   TypeRefOrLifetime? -> S96
    //   Lifetime -> S91
    //   TypeRefOrLifetime -> S97
    pub fn __state81<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state93(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state95(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state100(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state94(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action147(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state92(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state98(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state99(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state89(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state90(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::TypeRefOrLifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state96(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state91(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::TypeRefOrLifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state97(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 82
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [")"]
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [","]
    //
    //   ">" -> Shift(S101)
    //
    pub fn __state82<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state101(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 83
    //   (<NonterminalId> ",")* = (*) [">"]
    //   (<NonterminalId> ",")* = (*) ["Id"]
    //   (<NonterminalId> ",")* = (*) (<NonterminalId> ",")* (<NonterminalId> ",") [">"]
    //   (<NonterminalId> ",")* = (*) (<NonterminalId> ",")* (<NonterminalId> ",") ["Id"]
    //   Comma<NonterminalId> = (*) (<NonterminalId> ",")* NonterminalId? [">"]
    //   NonterminalName = MacroId "<" (*) Comma<NonterminalId> ">" [":"]
    //   NonterminalName = MacroId "<" (*) Comma<NonterminalId> ">" ["="]
    //
    //   ">" -> Reduce((<NonterminalId> ",")* =  => Call(ActionFn(133));)
    //   "Id" -> Reduce((<NonterminalId> ",")* =  => Call(ActionFn(133));)
    //
    //   Comma<NonterminalId> -> S103
    //   (<NonterminalId> ",")* -> S102
    pub fn __state83<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action133(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cNonterminalId_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action133(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cNonterminalId_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cNonterminalId_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state103(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cNonterminalId_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state102(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 84
    //   (":" <TypeRef>) = (*) ":" TypeRef ["="]
    //   (":" <TypeRef>)? = (*) ["="]
    //   (":" <TypeRef>)? = (*) (":" <TypeRef>) ["="]
    //   Nonterminal = "pub"? @L NonterminalName @R (*) (":" <TypeRef>)? "=" Alternatives [EOF]
    //   Nonterminal = "pub"? @L NonterminalName @R (*) (":" <TypeRef>)? "=" Alternatives ["Escape"]
    //   Nonterminal = "pub"? @L NonterminalName @R (*) (":" <TypeRef>)? "=" Alternatives ["Id"]
    //   Nonterminal = "pub"? @L NonterminalName @R (*) (":" <TypeRef>)? "=" Alternatives ["MacroId"]
    //   Nonterminal = "pub"? @L NonterminalName @R (*) (":" <TypeRef>)? "=" Alternatives ["extern"]
    //   Nonterminal = "pub"? @L NonterminalName @R (*) (":" <TypeRef>)? "=" Alternatives ["pub"]
    //   Nonterminal = "pub"? @L NonterminalName @R (*) (":" <TypeRef>)? "=" Alternatives ["use"]
    //
    //   "=" -> Reduce((":" <TypeRef>)? =  => Call(ActionFn(105));)
    //   ":" -> Shift(S104)
    //
    //   (":" <TypeRef>) -> S106
    //   (":" <TypeRef>)? -> S105
    pub fn __state84<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<(NonterminalString, Vec<NonterminalString>)>,
        __sym3: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Colon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state104(text, __lookbehind, __lookahead, __tokens, __sym4));
            }
            Some((_, Tok::Equals(..), _)) => {
                let __nt = super::__action105(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22_3a_22_20_3cTypeRef_3e_29_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym3.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_22_3a_22_20_3cTypeRef_3e_29(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state106(text, __lookbehind, __lookahead, __tokens, __sym4));
                }
                __Nonterminal::_28_22_3a_22_20_3cTypeRef_3e_29_3f(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state105(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 85
    //   ExternToken = @L "extern" "token" @R (*) "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R (*) "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R (*) "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R (*) "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R (*) "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R (*) "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R (*) "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "{" -> Shift(S107)
    //
    pub fn __state85<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state107(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 86
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [")"]
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [","]
    //
    //   "," -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //   ")" -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //
    pub fn __state86<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym3: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 87
    //   (<TypeRef> ",") = TypeRef "," (*) ["&"]
    //   (<TypeRef> ",") = TypeRef "," (*) ["("]
    //   (<TypeRef> ",") = TypeRef "," (*) [")"]
    //   (<TypeRef> ",") = TypeRef "," (*) ["::"]
    //   (<TypeRef> ",") = TypeRef "," (*) ["Escape"]
    //   (<TypeRef> ",") = TypeRef "," (*) ["Id"]
    //
    //   "(" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   "::" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   "&" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   ")" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   "Id" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   "Escape" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //
    pub fn __state87<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 88
    //   (<Id> "::") = Id "::" (*) ["Id"]
    //
    //   "Id" -> Reduce((<Id> "::") = Id, "::" => Call(ActionFn(84));)
    //
    pub fn __state88<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action84(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 89
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id [","]
    //   Path = "::"? (*) (<Id> "::")* Id ["<"]
    //   Path = "::"? (*) (<Id> "::")* Id [">"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S108
    pub fn __state89<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state108(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 90
    //   TypeRef = Path (*) [","]
    //   TypeRef = Path (*) [">"]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [">"]
    //
    //   "," -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //   "<" -> Shift(S109)
    //   ">" -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //
    pub fn __state90<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state109(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 91
    //   TypeRefOrLifetime = Lifetime (*) [","]
    //   TypeRefOrLifetime = Lifetime (*) [">"]
    //
    //   "," -> Reduce(TypeRefOrLifetime = Lifetime => Call(ActionFn(51));)
    //   ">" -> Reduce(TypeRefOrLifetime = Lifetime => Call(ActionFn(51));)
    //
    pub fn __state91<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action51(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action51(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 92
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["Lifetime"]
    //
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //
    pub fn __state92<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
        __sym1: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 93
    //   Escape = "Escape" (*) [","]
    //   Escape = "Escape" (*) [">"]
    //
    //   ">" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "," -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state93<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 94
    //   (<TypeRef> ",")* = (*) ["&"]
    //   (<TypeRef> ",")* = (*) ["("]
    //   (<TypeRef> ",")* = (*) [")"]
    //   (<TypeRef> ",")* = (*) ["::"]
    //   (<TypeRef> ",")* = (*) ["Escape"]
    //   (<TypeRef> ",")* = (*) ["Id"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (*) (<TypeRef> ",")* TypeRef? [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [","]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [">"]
    //
    //   "Id" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "(" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "&" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Escape" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "::" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   ")" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //
    //   Comma<TypeRef> -> S110
    //   (<TypeRef> ",")* -> S60
    pub fn __state94<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRef_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state110(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state60(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 95
    //   Lifetime = "Lifetime" (*) [","]
    //   Lifetime = "Lifetime" (*) [">"]
    //
    //   ">" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "," -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //
    pub fn __state95<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 96
    //   Comma<TypeRefOrLifetime> = (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? (*) [">"]
    //
    //   ">" -> Reduce(Comma<TypeRefOrLifetime> = (<TypeRefOrLifetime> ",")*, TypeRefOrLifetime? => Call(ActionFn(87));)
    //
    pub fn __state96<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
        __sym1: &mut Option<::std::option::Option<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action87(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 97
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["&"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["("]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["::"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," [">"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["Escape"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["Id"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["Lifetime"]
    //   TypeRefOrLifetime? = TypeRefOrLifetime (*) [">"]
    //
    //   ">" -> Reduce(TypeRefOrLifetime? = TypeRefOrLifetime => Call(ActionFn(146));)
    //   "," -> Shift(S111)
    //
    pub fn __state97<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state111(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action146(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 98
    //   TypeRefOrLifetime = TypeRef (*) [","]
    //   TypeRefOrLifetime = TypeRef (*) [">"]
    //
    //   "," -> Reduce(TypeRefOrLifetime = TypeRef => Call(ActionFn(50));)
    //   ">" -> Reduce(TypeRefOrLifetime = TypeRef => Call(ActionFn(50));)
    //
    pub fn __state98<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action50(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action50(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 99
    //   TypeRef = Escape (*) [","]
    //   TypeRef = Escape (*) [">"]
    //
    //   ">" -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //   "," -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //
    pub fn __state99<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 100
    //   Lifetime = (*) "Lifetime" ["&"]
    //   Lifetime = (*) "Lifetime" ["("]
    //   Lifetime = (*) "Lifetime" ["::"]
    //   Lifetime = (*) "Lifetime" ["Escape"]
    //   Lifetime = (*) "Lifetime" ["Id"]
    //   Lifetime = (*) "Lifetime" ["mut"]
    //   Lifetime? = (*) ["&"]
    //   Lifetime? = (*) ["("]
    //   Lifetime? = (*) ["::"]
    //   Lifetime? = (*) ["Escape"]
    //   Lifetime? = (*) ["Id"]
    //   Lifetime? = (*) ["mut"]
    //   Lifetime? = (*) Lifetime ["&"]
    //   Lifetime? = (*) Lifetime ["("]
    //   Lifetime? = (*) Lifetime ["::"]
    //   Lifetime? = (*) Lifetime ["Escape"]
    //   Lifetime? = (*) Lifetime ["Id"]
    //   Lifetime? = (*) Lifetime ["mut"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [","]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [">"]
    //
    //   "&" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "mut" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Id" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "(" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Lifetime" -> Shift(S58)
    //   "Escape" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "::" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //
    //   Lifetime -> S59
    //   Lifetime? -> S112
    pub fn __state100<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state58(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state59(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Lifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state112(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 101
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [")"]
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [","]
    //
    //   "," -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //   ")" -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //
    pub fn __state101<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 102
    //   (<NonterminalId> ",") = (*) NonterminalId "," [">"]
    //   (<NonterminalId> ",") = (*) NonterminalId "," ["Id"]
    //   (<NonterminalId> ",")* = (<NonterminalId> ",")* (*) (<NonterminalId> ",") [">"]
    //   (<NonterminalId> ",")* = (<NonterminalId> ",")* (*) (<NonterminalId> ",") ["Id"]
    //   Comma<NonterminalId> = (<NonterminalId> ",")* (*) NonterminalId? [">"]
    //   Id = (*) "Id" [","]
    //   Id = (*) "Id" [">"]
    //   NonterminalId = (*) Id [","]
    //   NonterminalId = (*) Id [">"]
    //   NonterminalId? = (*) [">"]
    //   NonterminalId? = (*) NonterminalId [">"]
    //
    //   "Id" -> Shift(S115)
    //   ">" -> Reduce(NonterminalId? =  => Call(ActionFn(132));)
    //
    //   NonterminalId -> S116
    //   NonterminalId? -> S117
    //   Id -> S114
    //   (<NonterminalId> ",") -> S113
    pub fn __state102<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<NonterminalString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state115(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action132(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::NonterminalId_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state116(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::NonterminalId_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state117(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state114(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_28_3cNonterminalId_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state113(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 103
    //   NonterminalName = MacroId "<" Comma<NonterminalId> (*) ">" [":"]
    //   NonterminalName = MacroId "<" Comma<NonterminalId> (*) ">" ["="]
    //
    //   ">" -> Shift(S118)
    //
    pub fn __state103<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<NonterminalString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state118(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 104
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   (":" <TypeRef>) = ":" (*) TypeRef ["="]
    //   Escape = (*) "Escape" ["="]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id ["="]
    //   TypeRef = (*) Escape ["="]
    //   TypeRef = (*) Path ["="]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" ["="]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef ["="]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" ["="]
    //
    //   "&" -> Shift(S122)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "(" -> Shift(S125)
    //   "::" -> Shift(S50)
    //   "Escape" -> Shift(S120)
    //
    //   Path -> S121
    //   Escape -> S124
    //   TypeRef -> S119
    //   "::"? -> S123
    pub fn __state104<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state122(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state125(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state120(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state121(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state124(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state119(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state123(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 105
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? (*) "=" Alternatives [EOF]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? (*) "=" Alternatives ["Escape"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? (*) "=" Alternatives ["Id"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? (*) "=" Alternatives ["MacroId"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? (*) "=" Alternatives ["extern"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? (*) "=" Alternatives ["pub"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? (*) "=" Alternatives ["use"]
    //
    //   "=" -> Shift(S126)
    //
    pub fn __state105<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<(NonterminalString, Vec<NonterminalString>)>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<::std::option::Option<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Equals(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state126(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 106
    //   (":" <TypeRef>)? = (":" <TypeRef>) (*) ["="]
    //
    //   "=" -> Reduce((":" <TypeRef>)? = (":" <TypeRef>) => Call(ActionFn(104));)
    //
    pub fn __state106<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action104(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22_3a_22_20_3cTypeRef_3e_29_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 107
    //   AssociatedType* = (*) ["enum"]
    //   AssociatedType* = (*) ["type"]
    //   AssociatedType* = (*) AssociatedType* AssociatedType ["enum"]
    //   AssociatedType* = (*) AssociatedType* AssociatedType ["type"]
    //   ExternToken = @L "extern" "token" @R "{" (*) AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" (*) AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" (*) AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" (*) AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" (*) AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" (*) AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" (*) AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "enum" -> Reduce(AssociatedType* =  => Call(ActionFn(80));)
    //   "type" -> Reduce(AssociatedType* =  => Call(ActionFn(80));)
    //
    //   AssociatedType* -> S127
    pub fn __state107<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Enum(..), _)) => {
                let __nt = super::__action80(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::AssociatedType_2a(__nt));
            }
            Some((_, Tok::Type(..), _)) => {
                let __nt = super::__action80(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::AssociatedType_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym4.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::AssociatedType_2a(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state127(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 108
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" [","]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["<"]
    //   Id = (*) "Id" [">"]
    //   Path = "::"? (<Id> "::")* (*) Id [","]
    //   Path = "::"? (<Id> "::")* (*) Id ["<"]
    //   Path = "::"? (<Id> "::")* (*) Id [">"]
    //
    //   "Id" -> Shift(S129)
    //
    //   (<Id> "::") -> S80
    //   Id -> S128
    pub fn __state108<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state129(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state80(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state128(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 109
    //   (<TypeRefOrLifetime> ",")* = (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (*) (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? [">"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [">"]
    //
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //
    //   Comma<TypeRefOrLifetime> -> S130
    //   (<TypeRefOrLifetime> ",")* -> S81
    pub fn __state109<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state130(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state81(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 110
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [","]
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [">"]
    //
    //   ")" -> Shift(S131)
    //
    pub fn __state110<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state131(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 111
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["&"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["("]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["::"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) [">"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["Id"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["Lifetime"]
    //
    //   ">" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "&" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //
    pub fn __state111<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 112
    //   "mut"? = (*) ["&"]
    //   "mut"? = (*) ["("]
    //   "mut"? = (*) ["::"]
    //   "mut"? = (*) ["Escape"]
    //   "mut"? = (*) ["Id"]
    //   "mut"? = (*) "mut" ["&"]
    //   "mut"? = (*) "mut" ["("]
    //   "mut"? = (*) "mut" ["::"]
    //   "mut"? = (*) "mut" ["Escape"]
    //   "mut"? = (*) "mut" ["Id"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [","]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [">"]
    //
    //   "mut" -> Shift(S73)
    //   "Id" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "::" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "Escape" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "&" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "(" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //
    //   "mut"? -> S132
    pub fn __state112<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Mut(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state73(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22mut_22_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state132(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 113
    //   (<NonterminalId> ",")* = (<NonterminalId> ",")* (<NonterminalId> ",") (*) [">"]
    //   (<NonterminalId> ",")* = (<NonterminalId> ",")* (<NonterminalId> ",") (*) ["Id"]
    //
    //   ">" -> Reduce((<NonterminalId> ",")* = (<NonterminalId> ",")*, (<NonterminalId> ",") => Call(ActionFn(134));)
    //   "Id" -> Reduce((<NonterminalId> ",")* = (<NonterminalId> ",")*, (<NonterminalId> ",") => Call(ActionFn(134));)
    //
    pub fn __state113<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<NonterminalString>>,
        __sym1: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action134(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cNonterminalId_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action134(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cNonterminalId_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 114
    //   NonterminalId = Id (*) [","]
    //   NonterminalId = Id (*) [">"]
    //
    //   ">" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "," -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //
    pub fn __state114<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 115
    //   Id = "Id" (*) [","]
    //   Id = "Id" (*) [">"]
    //
    //   ">" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "," -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state115<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 116
    //   (<NonterminalId> ",") = NonterminalId (*) "," [">"]
    //   (<NonterminalId> ",") = NonterminalId (*) "," ["Id"]
    //   NonterminalId? = NonterminalId (*) [">"]
    //
    //   "," -> Shift(S133)
    //   ">" -> Reduce(NonterminalId? = NonterminalId => Call(ActionFn(131));)
    //
    pub fn __state116<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state133(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action131(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 117
    //   Comma<NonterminalId> = (<NonterminalId> ",")* NonterminalId? (*) [">"]
    //
    //   ">" -> Reduce(Comma<NonterminalId> = (<NonterminalId> ",")*, NonterminalId? => Call(ActionFn(103));)
    //
    pub fn __state117<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<NonterminalString>>,
        __sym1: &mut Option<::std::option::Option<NonterminalString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action103(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cNonterminalId_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 118
    //   NonterminalName = MacroId "<" Comma<NonterminalId> ">" (*) [":"]
    //   NonterminalName = MacroId "<" Comma<NonterminalId> ">" (*) ["="]
    //
    //   ":" -> Reduce(NonterminalName = MacroId, "<", Comma<NonterminalId>, ">" => Call(ActionFn(13));)
    //   "=" -> Reduce(NonterminalName = MacroId, "<", Comma<NonterminalId>, ">" => Call(ActionFn(13));)
    //
    pub fn __state118<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<NonterminalString>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Colon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action13(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalName(__nt)));
            }
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action13(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalName(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 119
    //   (":" <TypeRef>) = ":" TypeRef (*) ["="]
    //
    //   "=" -> Reduce((":" <TypeRef>) = ":", TypeRef => Call(ActionFn(106));)
    //
    pub fn __state119<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action106(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22_3a_22_20_3cTypeRef_3e_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 120
    //   Escape = "Escape" (*) ["="]
    //
    //   "=" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state120<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 121
    //   TypeRef = Path (*) ["="]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" ["="]
    //
    //   "=" -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //   "<" -> Shift(S134)
    //
    pub fn __state121<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state134(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 122
    //   Lifetime = (*) "Lifetime" ["&"]
    //   Lifetime = (*) "Lifetime" ["("]
    //   Lifetime = (*) "Lifetime" ["::"]
    //   Lifetime = (*) "Lifetime" ["Escape"]
    //   Lifetime = (*) "Lifetime" ["Id"]
    //   Lifetime = (*) "Lifetime" ["mut"]
    //   Lifetime? = (*) ["&"]
    //   Lifetime? = (*) ["("]
    //   Lifetime? = (*) ["::"]
    //   Lifetime? = (*) ["Escape"]
    //   Lifetime? = (*) ["Id"]
    //   Lifetime? = (*) ["mut"]
    //   Lifetime? = (*) Lifetime ["&"]
    //   Lifetime? = (*) Lifetime ["("]
    //   Lifetime? = (*) Lifetime ["::"]
    //   Lifetime? = (*) Lifetime ["Escape"]
    //   Lifetime? = (*) Lifetime ["Id"]
    //   Lifetime? = (*) Lifetime ["mut"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef ["="]
    //
    //   "mut" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Lifetime" -> Shift(S58)
    //   "(" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Id" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Escape" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "&" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "::" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //
    //   Lifetime? -> S135
    //   Lifetime -> S59
    pub fn __state122<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state58(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Lifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state135(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state59(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 123
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id ["<"]
    //   Path = "::"? (*) (<Id> "::")* Id ["="]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S136
    pub fn __state123<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state136(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 124
    //   TypeRef = Escape (*) ["="]
    //
    //   "=" -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //
    pub fn __state124<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 125
    //   (<TypeRef> ",")* = (*) ["&"]
    //   (<TypeRef> ",")* = (*) ["("]
    //   (<TypeRef> ",")* = (*) [")"]
    //   (<TypeRef> ",")* = (*) ["::"]
    //   (<TypeRef> ",")* = (*) ["Escape"]
    //   (<TypeRef> ",")* = (*) ["Id"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (*) (<TypeRef> ",")* TypeRef? [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" ["="]
    //
    //   "Id" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Escape" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "::" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "(" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "&" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   ")" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //
    //   (<TypeRef> ",")* -> S60
    //   Comma<TypeRef> -> S137
    pub fn __state125<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state60(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Comma_3cTypeRef_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state137(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 126
    //   @L = (*) ["("]
    //   @L = (*) [";"]
    //   @L = (*) ["<"]
    //   @L = (*) ["=>"]
    //   @L = (*) ["=>?"]
    //   @L = (*) ["=>@L"]
    //   @L = (*) ["=>@R"]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   @L = (*) ["if"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R [EOF]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["Escape"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["Id"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["MacroId"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["extern"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["pub"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["use"]
    //   Alternatives = (*) Alternative [EOF]
    //   Alternatives = (*) Alternative ["Escape"]
    //   Alternatives = (*) Alternative ["Id"]
    //   Alternatives = (*) Alternative ["MacroId"]
    //   Alternatives = (*) Alternative ["extern"]
    //   Alternatives = (*) Alternative ["pub"]
    //   Alternatives = (*) Alternative ["use"]
    //   Alternatives = (*) "{" Alternative* "}" ";" [EOF]
    //   Alternatives = (*) "{" Alternative* "}" ";" ["Escape"]
    //   Alternatives = (*) "{" Alternative* "}" ";" ["Id"]
    //   Alternatives = (*) "{" Alternative* "}" ";" ["MacroId"]
    //   Alternatives = (*) "{" Alternative* "}" ";" ["extern"]
    //   Alternatives = (*) "{" Alternative* "}" ";" ["pub"]
    //   Alternatives = (*) "{" Alternative* "}" ";" ["use"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" (*) Alternatives [EOF]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" (*) Alternatives ["Escape"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" (*) Alternatives ["Id"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" (*) Alternatives ["MacroId"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" (*) Alternatives ["extern"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" (*) Alternatives ["pub"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" (*) Alternatives ["use"]
    //
    //   "{" -> Shift(S139)
    //   "=>" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "=>?" -> Reduce(@L =  => Lookahead;)
    //   "if" -> Reduce(@L =  => Lookahead;)
    //   ";" -> Reduce(@L =  => Lookahead;)
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "=>@L" -> Reduce(@L =  => Lookahead;)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "<" -> Reduce(@L =  => Lookahead;)
    //   "=>@R" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //
    //   Alternatives -> S141
    //   @L -> S138
    //   Alternative -> S140
    pub fn __state126<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<(NonterminalString, Vec<NonterminalString>)>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<::std::option::Option<TypeRef>>,
        __sym5: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state139(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym5.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Alternatives(__nt) => {
                    let __sym6 = &mut Some(__nt);
                    __result = try!(__state141(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym6 = &mut Some(__nt);
                    __result = try!(__state138(text, __lookbehind, __lookahead, __tokens, __sym6));
                }
                __Nonterminal::Alternative(__nt) => {
                    let __sym6 = &mut Some(__nt);
                    __result = try!(__state140(text, __lookbehind, __lookahead, __tokens, __sym6));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 127
    //   AssociatedType = (*) "type" @L Id @R "=" TypeRef ";" ["enum"]
    //   AssociatedType = (*) "type" @L Id @R "=" TypeRef ";" ["type"]
    //   AssociatedType* = AssociatedType* (*) AssociatedType ["enum"]
    //   AssociatedType* = AssociatedType* (*) AssociatedType ["type"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* (*) "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* (*) "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* (*) "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* (*) "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* (*) "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* (*) "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* (*) "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "type" -> Shift(S144)
    //   "enum" -> Shift(S142)
    //
    //   AssociatedType -> S143
    pub fn __state127<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Type(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state144(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, __tok @ Tok::Enum(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state142(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym5.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::AssociatedType(__nt) => {
                    let __sym6 = &mut Some(__nt);
                    __result = try!(__state143(text, __lookbehind, __lookahead, __tokens, __sym5, __sym6));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 128
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) [","]
    //   Path = "::"? (<Id> "::")* Id (*) ["<"]
    //   Path = "::"? (<Id> "::")* Id (*) [">"]
    //
    //   "<" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S88)
    //   "," -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   ">" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //
    pub fn __state128<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state88(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 129
    //   Id = "Id" (*) [","]
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["<"]
    //   Id = "Id" (*) [">"]
    //
    //   ">" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "," -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state129<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 130
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [","]
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [">"]
    //
    //   ">" -> Shift(S145)
    //
    pub fn __state130<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state145(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 131
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [","]
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [">"]
    //
    //   ">" -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //   "," -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //
    pub fn __state131<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 132
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [","]
    //   Escape = (*) "Escape" [">"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id [">"]
    //   TypeRef = (*) Escape [","]
    //   TypeRef = (*) Escape [">"]
    //   TypeRef = (*) Path [","]
    //   TypeRef = (*) Path [">"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [">"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [","]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [">"]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [","]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [">"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [","]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [">"]
    //
    //   "(" -> Shift(S94)
    //   "::" -> Shift(S50)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "&" -> Shift(S100)
    //   "Escape" -> Shift(S93)
    //
    //   Path -> S90
    //   Escape -> S99
    //   TypeRef -> S146
    //   "::"? -> S89
    pub fn __state132<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state94(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state100(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state93(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Path(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state90(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state99(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state146(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state89(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 133
    //   (<NonterminalId> ",") = NonterminalId "," (*) [">"]
    //   (<NonterminalId> ",") = NonterminalId "," (*) ["Id"]
    //
    //   ">" -> Reduce((<NonterminalId> ",") = NonterminalId, "," => Call(ActionFn(135));)
    //   "Id" -> Reduce((<NonterminalId> ",") = NonterminalId, "," => Call(ActionFn(135));)
    //
    pub fn __state133<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action135(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cNonterminalId_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action135(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cNonterminalId_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 134
    //   (<TypeRefOrLifetime> ",")* = (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (*) (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? [">"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" ["="]
    //
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //
    //   (<TypeRefOrLifetime> ",")* -> S81
    //   Comma<TypeRefOrLifetime> -> S147
    pub fn __state134<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state81(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state147(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 135
    //   "mut"? = (*) ["&"]
    //   "mut"? = (*) ["("]
    //   "mut"? = (*) ["::"]
    //   "mut"? = (*) ["Escape"]
    //   "mut"? = (*) ["Id"]
    //   "mut"? = (*) "mut" ["&"]
    //   "mut"? = (*) "mut" ["("]
    //   "mut"? = (*) "mut" ["::"]
    //   "mut"? = (*) "mut" ["Escape"]
    //   "mut"? = (*) "mut" ["Id"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef ["="]
    //
    //   "(" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "::" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "mut" -> Shift(S73)
    //   "Escape" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "&" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "Id" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //
    //   "mut"? -> S148
    pub fn __state135<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Mut(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state73(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22mut_22_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state148(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 136
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["<"]
    //   Id = (*) "Id" ["="]
    //   Path = "::"? (<Id> "::")* (*) Id ["<"]
    //   Path = "::"? (<Id> "::")* (*) Id ["="]
    //
    //   "Id" -> Shift(S150)
    //
    //   Id -> S149
    //   (<Id> "::") -> S80
    pub fn __state136<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state150(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state149(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state80(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 137
    //   TypeRef = "(" Comma<TypeRef> (*) ")" ["="]
    //
    //   ")" -> Shift(S151)
    //
    pub fn __state137<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state151(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 138
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R [EOF]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["Escape"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["Id"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["MacroId"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["extern"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["pub"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["use"]
    //   ExprSymbol = (*) Symbol* [";"]
    //   ExprSymbol = (*) Symbol* ["=>"]
    //   ExprSymbol = (*) Symbol* ["=>?"]
    //   ExprSymbol = (*) Symbol* ["=>@L"]
    //   ExprSymbol = (*) Symbol* ["=>@R"]
    //   ExprSymbol = (*) Symbol* ["if"]
    //   Symbol* = (*) ["("]
    //   Symbol* = (*) [";"]
    //   Symbol* = (*) ["<"]
    //   Symbol* = (*) ["=>"]
    //   Symbol* = (*) ["=>?"]
    //   Symbol* = (*) ["=>@L"]
    //   Symbol* = (*) ["=>@R"]
    //   Symbol* = (*) ["@L"]
    //   Symbol* = (*) ["@R"]
    //   Symbol* = (*) ["Escape"]
    //   Symbol* = (*) ["Id"]
    //   Symbol* = (*) ["MacroId"]
    //   Symbol* = (*) ["StringLiteral"]
    //   Symbol* = (*) ["if"]
    //   Symbol* = (*) Symbol* Symbol ["("]
    //   Symbol* = (*) Symbol* Symbol [";"]
    //   Symbol* = (*) Symbol* Symbol ["<"]
    //   Symbol* = (*) Symbol* Symbol ["=>"]
    //   Symbol* = (*) Symbol* Symbol ["=>?"]
    //   Symbol* = (*) Symbol* Symbol ["=>@L"]
    //   Symbol* = (*) Symbol* Symbol ["=>@R"]
    //   Symbol* = (*) Symbol* Symbol ["@L"]
    //   Symbol* = (*) Symbol* Symbol ["@R"]
    //   Symbol* = (*) Symbol* Symbol ["Escape"]
    //   Symbol* = (*) Symbol* Symbol ["Id"]
    //   Symbol* = (*) Symbol* Symbol ["MacroId"]
    //   Symbol* = (*) Symbol* Symbol ["StringLiteral"]
    //   Symbol* = (*) Symbol* Symbol ["if"]
    //
    //   "(" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@L" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "=>" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Id" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@R" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "=>@R" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "MacroId" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "<" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "=>@L" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "StringLiteral" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "if" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Escape" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "=>?" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   ";" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //
    //   ExprSymbol -> S152
    //   Symbol* -> S153
    pub fn __state138<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::ExprSymbol(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state152(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Symbol_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state153(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 139
    //   Alternative* = (*) ["("]
    //   Alternative* = (*) [";"]
    //   Alternative* = (*) ["<"]
    //   Alternative* = (*) ["=>"]
    //   Alternative* = (*) ["=>?"]
    //   Alternative* = (*) ["=>@L"]
    //   Alternative* = (*) ["=>@R"]
    //   Alternative* = (*) ["@L"]
    //   Alternative* = (*) ["@R"]
    //   Alternative* = (*) ["Escape"]
    //   Alternative* = (*) ["Id"]
    //   Alternative* = (*) ["MacroId"]
    //   Alternative* = (*) ["StringLiteral"]
    //   Alternative* = (*) ["if"]
    //   Alternative* = (*) ["}"]
    //   Alternative* = (*) Alternative* Alternative ["("]
    //   Alternative* = (*) Alternative* Alternative [";"]
    //   Alternative* = (*) Alternative* Alternative ["<"]
    //   Alternative* = (*) Alternative* Alternative ["=>"]
    //   Alternative* = (*) Alternative* Alternative ["=>?"]
    //   Alternative* = (*) Alternative* Alternative ["=>@L"]
    //   Alternative* = (*) Alternative* Alternative ["=>@R"]
    //   Alternative* = (*) Alternative* Alternative ["@L"]
    //   Alternative* = (*) Alternative* Alternative ["@R"]
    //   Alternative* = (*) Alternative* Alternative ["Escape"]
    //   Alternative* = (*) Alternative* Alternative ["Id"]
    //   Alternative* = (*) Alternative* Alternative ["MacroId"]
    //   Alternative* = (*) Alternative* Alternative ["StringLiteral"]
    //   Alternative* = (*) Alternative* Alternative ["if"]
    //   Alternative* = (*) Alternative* Alternative ["}"]
    //   Alternatives = "{" (*) Alternative* "}" ";" [EOF]
    //   Alternatives = "{" (*) Alternative* "}" ";" ["Escape"]
    //   Alternatives = "{" (*) Alternative* "}" ";" ["Id"]
    //   Alternatives = "{" (*) Alternative* "}" ";" ["MacroId"]
    //   Alternatives = "{" (*) Alternative* "}" ";" ["extern"]
    //   Alternatives = "{" (*) Alternative* "}" ";" ["pub"]
    //   Alternatives = "{" (*) Alternative* "}" ";" ["use"]
    //
    //   ";" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "StringLiteral" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "MacroId" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "=>?" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "=>" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "=>@R" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "=>@L" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "@L" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "Id" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "}" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "<" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "(" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "@R" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "Escape" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //   "if" -> Reduce(Alternative* =  => Call(ActionFn(101));)
    //
    //   Alternative* -> S154
    pub fn __state139<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __nt = super::__action101(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Alternative_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state154(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 140
    //   Alternatives = Alternative (*) [EOF]
    //   Alternatives = Alternative (*) ["Escape"]
    //   Alternatives = Alternative (*) ["Id"]
    //   Alternatives = Alternative (*) ["MacroId"]
    //   Alternatives = Alternative (*) ["extern"]
    //   Alternatives = Alternative (*) ["pub"]
    //   Alternatives = Alternative (*) ["use"]
    //
    //   "extern" -> Reduce(Alternatives = Alternative => Call(ActionFn(16));)
    //   "MacroId" -> Reduce(Alternatives = Alternative => Call(ActionFn(16));)
    //   "Escape" -> Reduce(Alternatives = Alternative => Call(ActionFn(16));)
    //   "use" -> Reduce(Alternatives = Alternative => Call(ActionFn(16));)
    //   "pub" -> Reduce(Alternatives = Alternative => Call(ActionFn(16));)
    //   "Id" -> Reduce(Alternatives = Alternative => Call(ActionFn(16));)
    //   EOF -> Reduce(Alternatives = Alternative => Call(ActionFn(16));)
    //
    pub fn __state140<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Alternative>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action16(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action16(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action16(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action16(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action16(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action16(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action16(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 141
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives (*) [EOF]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives (*) ["Escape"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives (*) ["Id"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives (*) ["MacroId"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives (*) ["extern"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives (*) ["pub"]
    //   Nonterminal = "pub"? @L NonterminalName @R (":" <TypeRef>)? "=" Alternatives (*) ["use"]
    //
    //   "pub" -> Reduce(Nonterminal = "pub"?, @L, NonterminalName, @R, (":" <TypeRef>)?, "=", Alternatives => Call(ActionFn(12));)
    //   "Id" -> Reduce(Nonterminal = "pub"?, @L, NonterminalName, @R, (":" <TypeRef>)?, "=", Alternatives => Call(ActionFn(12));)
    //   EOF -> Reduce(Nonterminal = "pub"?, @L, NonterminalName, @R, (":" <TypeRef>)?, "=", Alternatives => Call(ActionFn(12));)
    //   "extern" -> Reduce(Nonterminal = "pub"?, @L, NonterminalName, @R, (":" <TypeRef>)?, "=", Alternatives => Call(ActionFn(12));)
    //   "use" -> Reduce(Nonterminal = "pub"?, @L, NonterminalName, @R, (":" <TypeRef>)?, "=", Alternatives => Call(ActionFn(12));)
    //   "MacroId" -> Reduce(Nonterminal = "pub"?, @L, NonterminalName, @R, (":" <TypeRef>)?, "=", Alternatives => Call(ActionFn(12));)
    //   "Escape" -> Reduce(Nonterminal = "pub"?, @L, NonterminalName, @R, (":" <TypeRef>)?, "=", Alternatives => Call(ActionFn(12));)
    //
    pub fn __state141<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<(NonterminalString, Vec<NonterminalString>)>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<::std::option::Option<TypeRef>>,
        __sym5: &mut Option<Tok<'input>>,
        __sym6: &mut Option<Vec<Alternative>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action12(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Nonterminal(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action12(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Nonterminal(__nt)));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action12(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Nonterminal(__nt)));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action12(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Nonterminal(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action12(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Nonterminal(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action12(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Nonterminal(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action12(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Nonterminal(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 142
    //   @L = (*) ["&"]
    //   @L = (*) ["("]
    //   @L = (*) ["::"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" (*) @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" (*) @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" (*) @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" (*) @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" (*) @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" (*) @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" (*) @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "&" -> Reduce(@L =  => Lookahead;)
    //   "::" -> Reduce(@L =  => Lookahead;)
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //
    //   @L -> S155
    pub fn __state142<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym6: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym6.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym7 = &mut Some(__nt);
                    __result = try!(__state155(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 143
    //   AssociatedType* = AssociatedType* AssociatedType (*) ["enum"]
    //   AssociatedType* = AssociatedType* AssociatedType (*) ["type"]
    //
    //   "enum" -> Reduce(AssociatedType* = AssociatedType*, AssociatedType => Call(ActionFn(81));)
    //   "type" -> Reduce(AssociatedType* = AssociatedType*, AssociatedType => Call(ActionFn(81));)
    //
    pub fn __state143<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym1: &mut Option<AssociatedType>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Enum(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action81(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::AssociatedType_2a(__nt)));
            }
            Some((_, Tok::Type(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action81(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::AssociatedType_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 144
    //   @L = (*) ["Id"]
    //   AssociatedType = "type" (*) @L Id @R "=" TypeRef ";" ["enum"]
    //   AssociatedType = "type" (*) @L Id @R "=" TypeRef ";" ["type"]
    //
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //
    //   @L -> S156
    pub fn __state144<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state156(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 145
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [","]
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [">"]
    //
    //   ">" -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //   "," -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //
    pub fn __state145<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 146
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [","]
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [">"]
    //
    //   "," -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //   ">" -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //
    pub fn __state146<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym3: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 147
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" ["="]
    //
    //   ">" -> Shift(S157)
    //
    pub fn __state147<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state157(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 148
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" ["="]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id ["="]
    //   TypeRef = (*) Escape ["="]
    //   TypeRef = (*) Path ["="]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" ["="]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef ["="]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef ["="]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" ["="]
    //
    //   "(" -> Shift(S125)
    //   "&" -> Shift(S122)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "Escape" -> Shift(S120)
    //   "::" -> Shift(S50)
    //
    //   Path -> S121
    //   TypeRef -> S158
    //   Escape -> S124
    //   "::"? -> S123
    pub fn __state148<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state125(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state122(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state120(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Path(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state121(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state158(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state124(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state123(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 149
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) ["<"]
    //   Path = "::"? (<Id> "::")* Id (*) ["="]
    //
    //   "=" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "<" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S88)
    //
    pub fn __state149<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state88(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 150
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["<"]
    //   Id = "Id" (*) ["="]
    //
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "=" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state150<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 151
    //   TypeRef = "(" Comma<TypeRef> ")" (*) ["="]
    //
    //   "=" -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //
    pub fn __state151<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 152
    //   ("if" <Cond>) = (*) "if" Cond [";"]
    //   ("if" <Cond>) = (*) "if" Cond ["=>"]
    //   ("if" <Cond>) = (*) "if" Cond ["=>?"]
    //   ("if" <Cond>) = (*) "if" Cond ["=>@L"]
    //   ("if" <Cond>) = (*) "if" Cond ["=>@R"]
    //   ("if" <Cond>)? = (*) [";"]
    //   ("if" <Cond>)? = (*) ["=>"]
    //   ("if" <Cond>)? = (*) ["=>?"]
    //   ("if" <Cond>)? = (*) ["=>@L"]
    //   ("if" <Cond>)? = (*) ["=>@R"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) [";"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) ["=>"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) ["=>?"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) ["=>@L"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) ["=>@R"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R [EOF]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["Escape"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["Id"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["MacroId"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["extern"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["pub"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["use"]
    //
    //   "if" -> Shift(S160)
    //   "=>" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //   "=>?" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //   "=>@R" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //   ";" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //   "=>@L" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //
    //   ("if" <Cond>)? -> S161
    //   ("if" <Cond>) -> S159
    pub fn __state152<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::If(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state160(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state161(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_22if_22_20_3cCond_3e_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state159(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 153
    //   @L = (*) ["("]
    //   @L = (*) ["<"]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   ExprSymbol = Symbol* (*) [";"]
    //   ExprSymbol = Symbol* (*) ["=>"]
    //   ExprSymbol = Symbol* (*) ["=>?"]
    //   ExprSymbol = Symbol* (*) ["=>@L"]
    //   ExprSymbol = Symbol* (*) ["=>@R"]
    //   ExprSymbol = Symbol* (*) ["if"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["("]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R [";"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["<"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["=>"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["=>?"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["=>@L"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["=>@R"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["@L"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["@R"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["Id"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["if"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["("]
    //   Symbol = (*) @L "<" Symbol0 ">" @R [";"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["<"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["=>"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["=>?"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["=>@L"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["=>@R"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["@L"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["@R"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["Escape"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["Id"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["MacroId"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["if"]
    //   Symbol = (*) Symbol0 ["("]
    //   Symbol = (*) Symbol0 [";"]
    //   Symbol = (*) Symbol0 ["<"]
    //   Symbol = (*) Symbol0 ["=>"]
    //   Symbol = (*) Symbol0 ["=>?"]
    //   Symbol = (*) Symbol0 ["=>@L"]
    //   Symbol = (*) Symbol0 ["=>@R"]
    //   Symbol = (*) Symbol0 ["@L"]
    //   Symbol = (*) Symbol0 ["@R"]
    //   Symbol = (*) Symbol0 ["Escape"]
    //   Symbol = (*) Symbol0 ["Id"]
    //   Symbol = (*) Symbol0 ["MacroId"]
    //   Symbol = (*) Symbol0 ["StringLiteral"]
    //   Symbol = (*) Symbol0 ["if"]
    //   Symbol* = Symbol* (*) Symbol ["("]
    //   Symbol* = Symbol* (*) Symbol [";"]
    //   Symbol* = Symbol* (*) Symbol ["<"]
    //   Symbol* = Symbol* (*) Symbol ["=>"]
    //   Symbol* = Symbol* (*) Symbol ["=>?"]
    //   Symbol* = Symbol* (*) Symbol ["=>@L"]
    //   Symbol* = Symbol* (*) Symbol ["=>@R"]
    //   Symbol* = Symbol* (*) Symbol ["@L"]
    //   Symbol* = Symbol* (*) Symbol ["@R"]
    //   Symbol* = Symbol* (*) Symbol ["Escape"]
    //   Symbol* = Symbol* (*) Symbol ["Id"]
    //   Symbol* = Symbol* (*) Symbol ["MacroId"]
    //   Symbol* = Symbol* (*) Symbol ["StringLiteral"]
    //   Symbol* = Symbol* (*) Symbol ["if"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["("]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["*"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["+"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [";"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["<"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["=>"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["=>?"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["=>@L"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["=>@R"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["?"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["@L"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["@R"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["Escape"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["Id"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["MacroId"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["StringLiteral"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["if"]
    //   Symbol0 = (*) Symbol1 ["("]
    //   Symbol0 = (*) Symbol1 ["*"]
    //   Symbol0 = (*) Symbol1 ["+"]
    //   Symbol0 = (*) Symbol1 [";"]
    //   Symbol0 = (*) Symbol1 ["<"]
    //   Symbol0 = (*) Symbol1 ["=>"]
    //   Symbol0 = (*) Symbol1 ["=>?"]
    //   Symbol0 = (*) Symbol1 ["=>@L"]
    //   Symbol0 = (*) Symbol1 ["=>@R"]
    //   Symbol0 = (*) Symbol1 ["?"]
    //   Symbol0 = (*) Symbol1 ["@L"]
    //   Symbol0 = (*) Symbol1 ["@R"]
    //   Symbol0 = (*) Symbol1 ["Escape"]
    //   Symbol0 = (*) Symbol1 ["Id"]
    //   Symbol0 = (*) Symbol1 ["MacroId"]
    //   Symbol0 = (*) Symbol1 ["StringLiteral"]
    //   Symbol0 = (*) Symbol1 ["if"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["("]
    //   Symbol1 = (*) @L SymbolKind1 @R ["*"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["+"]
    //   Symbol1 = (*) @L SymbolKind1 @R [";"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["<"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["=>"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["=>?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["=>@L"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["=>@R"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["@L"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["@R"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["Escape"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["Id"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["MacroId"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["StringLiteral"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["if"]
    //
    //   "<" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "=>@R" -> Reduce(ExprSymbol = Symbol* => Call(ActionFn(28));)
    //   "=>" -> Reduce(ExprSymbol = Symbol* => Call(ActionFn(28));)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   ";" -> Reduce(ExprSymbol = Symbol* => Call(ActionFn(28));)
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "=>@L" -> Reduce(ExprSymbol = Symbol* => Call(ActionFn(28));)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "if" -> Reduce(ExprSymbol = Symbol* => Call(ActionFn(28));)
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "=>?" -> Reduce(ExprSymbol = Symbol* => Call(ActionFn(28));)
    //
    //   @L -> S163
    //   Symbol1 -> S164
    //   Symbol -> S165
    //   Symbol0 -> S162
    pub fn __state153<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Symbol>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action28(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExprSymbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action28(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExprSymbol(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action28(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExprSymbol(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action28(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExprSymbol(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action28(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExprSymbol(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action28(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExprSymbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state163(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Symbol1(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state164(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Symbol(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state165(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Symbol0(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state162(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 154
    //   @L = (*) ["("]
    //   @L = (*) [";"]
    //   @L = (*) ["<"]
    //   @L = (*) ["=>"]
    //   @L = (*) ["=>?"]
    //   @L = (*) ["=>@L"]
    //   @L = (*) ["=>@R"]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   @L = (*) ["if"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["("]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R [";"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["<"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["=>"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["=>?"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["=>@L"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["=>@R"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["@L"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["@R"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["Escape"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["Id"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["MacroId"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["StringLiteral"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["if"]
    //   Alternative = (*) @L ExprSymbol ("if" <Cond>)? Action? ";" @R ["}"]
    //   Alternative* = Alternative* (*) Alternative ["("]
    //   Alternative* = Alternative* (*) Alternative [";"]
    //   Alternative* = Alternative* (*) Alternative ["<"]
    //   Alternative* = Alternative* (*) Alternative ["=>"]
    //   Alternative* = Alternative* (*) Alternative ["=>?"]
    //   Alternative* = Alternative* (*) Alternative ["=>@L"]
    //   Alternative* = Alternative* (*) Alternative ["=>@R"]
    //   Alternative* = Alternative* (*) Alternative ["@L"]
    //   Alternative* = Alternative* (*) Alternative ["@R"]
    //   Alternative* = Alternative* (*) Alternative ["Escape"]
    //   Alternative* = Alternative* (*) Alternative ["Id"]
    //   Alternative* = Alternative* (*) Alternative ["MacroId"]
    //   Alternative* = Alternative* (*) Alternative ["StringLiteral"]
    //   Alternative* = Alternative* (*) Alternative ["if"]
    //   Alternative* = Alternative* (*) Alternative ["}"]
    //   Alternatives = "{" Alternative* (*) "}" ";" [EOF]
    //   Alternatives = "{" Alternative* (*) "}" ";" ["Escape"]
    //   Alternatives = "{" Alternative* (*) "}" ";" ["Id"]
    //   Alternatives = "{" Alternative* (*) "}" ";" ["MacroId"]
    //   Alternatives = "{" Alternative* (*) "}" ";" ["extern"]
    //   Alternatives = "{" Alternative* (*) "}" ";" ["pub"]
    //   Alternatives = "{" Alternative* (*) "}" ";" ["use"]
    //
    //   "=>" -> Reduce(@L =  => Lookahead;)
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "<" -> Reduce(@L =  => Lookahead;)
    //   "=>@R" -> Reduce(@L =  => Lookahead;)
    //   ";" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "if" -> Reduce(@L =  => Lookahead;)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "=>@L" -> Reduce(@L =  => Lookahead;)
    //   "}" -> Shift(S168)
    //   "=>?" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //
    //   Alternative -> S166
    //   @L -> S167
    pub fn __state154<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::vec::Vec<Alternative>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state168(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Alternative(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state166(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state167(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 155
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" ["{"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L (*) TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L (*) TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L (*) TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L (*) TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L (*) TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L (*) TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L (*) TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id ["{"]
    //   TypeRef = (*) Escape ["{"]
    //   TypeRef = (*) Path ["{"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" ["{"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef ["{"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" ["{"]
    //
    //   "::" -> Shift(S50)
    //   "&" -> Shift(S175)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "Escape" -> Shift(S170)
    //   "(" -> Shift(S171)
    //
    //   Path -> S169
    //   TypeRef -> S174
    //   Escape -> S173
    //   "::"? -> S172
    pub fn __state155<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym8 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym8));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym8 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state175(text, __lookbehind, __lookahead, __tokens, __sym8));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym8 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state170(text, __lookbehind, __lookahead, __tokens, __sym8));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym8 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state171(text, __lookbehind, __lookahead, __tokens, __sym8));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym7.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Path(__nt) => {
                    let __sym8 = &mut Some(__nt);
                    __result = try!(__state169(text, __lookbehind, __lookahead, __tokens, __sym8));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym8 = &mut Some(__nt);
                    __result = try!(__state174(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym8 = &mut Some(__nt);
                    __result = try!(__state173(text, __lookbehind, __lookahead, __tokens, __sym8));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym8 = &mut Some(__nt);
                    __result = try!(__state172(text, __lookbehind, __lookahead, __tokens, __sym8));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 156
    //   AssociatedType = "type" @L (*) Id @R "=" TypeRef ";" ["enum"]
    //   AssociatedType = "type" @L (*) Id @R "=" TypeRef ";" ["type"]
    //   Id = (*) "Id" ["="]
    //
    //   "Id" -> Shift(S176)
    //
    //   Id -> S177
    pub fn __state156<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state176(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state177(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 157
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) ["="]
    //
    //   "=" -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //
    pub fn __state157<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 158
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) ["="]
    //
    //   "=" -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //
    pub fn __state158<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym3: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 159
    //   ("if" <Cond>)? = ("if" <Cond>) (*) [";"]
    //   ("if" <Cond>)? = ("if" <Cond>) (*) ["=>"]
    //   ("if" <Cond>)? = ("if" <Cond>) (*) ["=>?"]
    //   ("if" <Cond>)? = ("if" <Cond>) (*) ["=>@L"]
    //   ("if" <Cond>)? = ("if" <Cond>) (*) ["=>@R"]
    //
    //   "=>?" -> Reduce(("if" <Cond>)? = ("if" <Cond>) => Call(ActionFn(98));)
    //   "=>" -> Reduce(("if" <Cond>)? = ("if" <Cond>) => Call(ActionFn(98));)
    //   "=>@L" -> Reduce(("if" <Cond>)? = ("if" <Cond>) => Call(ActionFn(98));)
    //   ";" -> Reduce(("if" <Cond>)? = ("if" <Cond>) => Call(ActionFn(98));)
    //   "=>@R" -> Reduce(("if" <Cond>)? = ("if" <Cond>) => Call(ActionFn(98));)
    //
    pub fn __state159<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Condition>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action98(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action98(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action98(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action98(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action98(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 160
    //   ("if" <Cond>) = "if" (*) Cond [";"]
    //   ("if" <Cond>) = "if" (*) Cond ["=>"]
    //   ("if" <Cond>) = "if" (*) Cond ["=>?"]
    //   ("if" <Cond>) = "if" (*) Cond ["=>@L"]
    //   ("if" <Cond>) = "if" (*) Cond ["=>@R"]
    //   @L = (*) ["Id"]
    //   Cond = (*) @L NonterminalId CondOp StringLiteral @R [";"]
    //   Cond = (*) @L NonterminalId CondOp StringLiteral @R ["=>"]
    //   Cond = (*) @L NonterminalId CondOp StringLiteral @R ["=>?"]
    //   Cond = (*) @L NonterminalId CondOp StringLiteral @R ["=>@L"]
    //   Cond = (*) @L NonterminalId CondOp StringLiteral @R ["=>@R"]
    //
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //
    //   @L -> S178
    //   Cond -> S179
    pub fn __state160<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state178(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Cond(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state179(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 161
    //   Action = (*) "=>" [";"]
    //   Action = (*) "=>?" [";"]
    //   Action = (*) "=>@L" [";"]
    //   Action = (*) "=>@R" [";"]
    //   Action? = (*) [";"]
    //   Action? = (*) Action [";"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R [EOF]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["Escape"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["Id"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["MacroId"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["extern"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["pub"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["use"]
    //
    //   "=>?" -> Shift(S183)
    //   ";" -> Reduce(Action? =  => Call(ActionFn(97));)
    //   "=>@R" -> Shift(S180)
    //   "=>" -> Shift(S184)
    //   "=>@L" -> Shift(S185)
    //
    //   Action -> S182
    //   Action? -> S181
    pub fn __state161<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<::std::option::Option<Condition>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanQuestionCode(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state183(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::EqualsGreaterThanLookbehind(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state180(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::EqualsGreaterThanCode(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state184(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::EqualsGreaterThanLookahead(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state185(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action97(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Action_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Action(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state182(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Action_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state181(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 162
    //   RepeatOp = (*) "*" ["("]
    //   RepeatOp = (*) "*" ["*"]
    //   RepeatOp = (*) "*" ["+"]
    //   RepeatOp = (*) "*" [";"]
    //   RepeatOp = (*) "*" ["<"]
    //   RepeatOp = (*) "*" ["=>"]
    //   RepeatOp = (*) "*" ["=>?"]
    //   RepeatOp = (*) "*" ["=>@L"]
    //   RepeatOp = (*) "*" ["=>@R"]
    //   RepeatOp = (*) "*" ["?"]
    //   RepeatOp = (*) "*" ["@L"]
    //   RepeatOp = (*) "*" ["@R"]
    //   RepeatOp = (*) "*" ["Escape"]
    //   RepeatOp = (*) "*" ["Id"]
    //   RepeatOp = (*) "*" ["MacroId"]
    //   RepeatOp = (*) "*" ["StringLiteral"]
    //   RepeatOp = (*) "*" ["if"]
    //   RepeatOp = (*) "+" ["("]
    //   RepeatOp = (*) "+" ["*"]
    //   RepeatOp = (*) "+" ["+"]
    //   RepeatOp = (*) "+" [";"]
    //   RepeatOp = (*) "+" ["<"]
    //   RepeatOp = (*) "+" ["=>"]
    //   RepeatOp = (*) "+" ["=>?"]
    //   RepeatOp = (*) "+" ["=>@L"]
    //   RepeatOp = (*) "+" ["=>@R"]
    //   RepeatOp = (*) "+" ["?"]
    //   RepeatOp = (*) "+" ["@L"]
    //   RepeatOp = (*) "+" ["@R"]
    //   RepeatOp = (*) "+" ["Escape"]
    //   RepeatOp = (*) "+" ["Id"]
    //   RepeatOp = (*) "+" ["MacroId"]
    //   RepeatOp = (*) "+" ["StringLiteral"]
    //   RepeatOp = (*) "+" ["if"]
    //   RepeatOp = (*) "?" ["("]
    //   RepeatOp = (*) "?" ["*"]
    //   RepeatOp = (*) "?" ["+"]
    //   RepeatOp = (*) "?" [";"]
    //   RepeatOp = (*) "?" ["<"]
    //   RepeatOp = (*) "?" ["=>"]
    //   RepeatOp = (*) "?" ["=>?"]
    //   RepeatOp = (*) "?" ["=>@L"]
    //   RepeatOp = (*) "?" ["=>@R"]
    //   RepeatOp = (*) "?" ["?"]
    //   RepeatOp = (*) "?" ["@L"]
    //   RepeatOp = (*) "?" ["@R"]
    //   RepeatOp = (*) "?" ["Escape"]
    //   RepeatOp = (*) "?" ["Id"]
    //   RepeatOp = (*) "?" ["MacroId"]
    //   RepeatOp = (*) "?" ["StringLiteral"]
    //   RepeatOp = (*) "?" ["if"]
    //   Symbol = Symbol0 (*) ["("]
    //   Symbol = Symbol0 (*) [";"]
    //   Symbol = Symbol0 (*) ["<"]
    //   Symbol = Symbol0 (*) ["=>"]
    //   Symbol = Symbol0 (*) ["=>?"]
    //   Symbol = Symbol0 (*) ["=>@L"]
    //   Symbol = Symbol0 (*) ["=>@R"]
    //   Symbol = Symbol0 (*) ["@L"]
    //   Symbol = Symbol0 (*) ["@R"]
    //   Symbol = Symbol0 (*) ["Escape"]
    //   Symbol = Symbol0 (*) ["Id"]
    //   Symbol = Symbol0 (*) ["MacroId"]
    //   Symbol = Symbol0 (*) ["StringLiteral"]
    //   Symbol = Symbol0 (*) ["if"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["("]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["*"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["+"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [";"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["<"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["=>"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["=>?"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["=>@L"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["=>@R"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["?"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["@L"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["@R"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["Escape"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["Id"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["MacroId"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["StringLiteral"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["if"]
    //
    //   "=>@L" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "@L" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "if" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "?" -> Shift(S187)
    //   "+" -> Shift(S188)
    //   "Escape" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "*" -> Shift(S186)
    //   "=>@R" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "(" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "=>" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "MacroId" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "@R" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "StringLiteral" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "<" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "Id" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "=>?" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   ";" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //
    //   RepeatOp -> S189
    pub fn __state162<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Question(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state187(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Plus(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state188(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Star(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state186(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::RepeatOp(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state189(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 163
    //   Escape = (*) "Escape" ["("]
    //   Escape = (*) "Escape" ["*"]
    //   Escape = (*) "Escape" ["+"]
    //   Escape = (*) "Escape" [";"]
    //   Escape = (*) "Escape" ["<"]
    //   Escape = (*) "Escape" ["=>"]
    //   Escape = (*) "Escape" ["=>?"]
    //   Escape = (*) "Escape" ["=>@L"]
    //   Escape = (*) "Escape" ["=>@R"]
    //   Escape = (*) "Escape" ["?"]
    //   Escape = (*) "Escape" ["@L"]
    //   Escape = (*) "Escape" ["@R"]
    //   Escape = (*) "Escape" ["Escape"]
    //   Escape = (*) "Escape" ["Id"]
    //   Escape = (*) "Escape" ["MacroId"]
    //   Escape = (*) "Escape" ["StringLiteral"]
    //   Escape = (*) "Escape" ["if"]
    //   Id = (*) "Id" ["("]
    //   Id = (*) "Id" ["*"]
    //   Id = (*) "Id" ["+"]
    //   Id = (*) "Id" [";"]
    //   Id = (*) "Id" ["<"]
    //   Id = (*) "Id" ["=>"]
    //   Id = (*) "Id" ["=>?"]
    //   Id = (*) "Id" ["=>@L"]
    //   Id = (*) "Id" ["=>@R"]
    //   Id = (*) "Id" ["?"]
    //   Id = (*) "Id" ["@L"]
    //   Id = (*) "Id" ["@R"]
    //   Id = (*) "Id" ["Escape"]
    //   Id = (*) "Id" ["Id"]
    //   Id = (*) "Id" ["MacroId"]
    //   Id = (*) "Id" ["StringLiteral"]
    //   Id = (*) "Id" ["if"]
    //   MacroId = (*) "MacroId" ["<"]
    //   NonterminalId = (*) Id ["("]
    //   NonterminalId = (*) Id ["*"]
    //   NonterminalId = (*) Id ["+"]
    //   NonterminalId = (*) Id [";"]
    //   NonterminalId = (*) Id ["<"]
    //   NonterminalId = (*) Id ["=>"]
    //   NonterminalId = (*) Id ["=>?"]
    //   NonterminalId = (*) Id ["=>@L"]
    //   NonterminalId = (*) Id ["=>@R"]
    //   NonterminalId = (*) Id ["?"]
    //   NonterminalId = (*) Id ["@L"]
    //   NonterminalId = (*) Id ["@R"]
    //   NonterminalId = (*) Id ["Escape"]
    //   NonterminalId = (*) Id ["Id"]
    //   NonterminalId = (*) Id ["MacroId"]
    //   NonterminalId = (*) Id ["StringLiteral"]
    //   NonterminalId = (*) Id ["if"]
    //   StringLiteral = (*) "StringLiteral" ["("]
    //   StringLiteral = (*) "StringLiteral" ["*"]
    //   StringLiteral = (*) "StringLiteral" ["+"]
    //   StringLiteral = (*) "StringLiteral" [";"]
    //   StringLiteral = (*) "StringLiteral" ["<"]
    //   StringLiteral = (*) "StringLiteral" ["=>"]
    //   StringLiteral = (*) "StringLiteral" ["=>?"]
    //   StringLiteral = (*) "StringLiteral" ["=>@L"]
    //   StringLiteral = (*) "StringLiteral" ["=>@R"]
    //   StringLiteral = (*) "StringLiteral" ["?"]
    //   StringLiteral = (*) "StringLiteral" ["@L"]
    //   StringLiteral = (*) "StringLiteral" ["@R"]
    //   StringLiteral = (*) "StringLiteral" ["Escape"]
    //   StringLiteral = (*) "StringLiteral" ["Id"]
    //   StringLiteral = (*) "StringLiteral" ["MacroId"]
    //   StringLiteral = (*) "StringLiteral" ["StringLiteral"]
    //   StringLiteral = (*) "StringLiteral" ["if"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["("]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R [";"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["<"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["=>"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["=>?"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["=>@L"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["=>@R"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["@L"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["@R"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["Id"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["if"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["("]
    //   Symbol = @L (*) "<" Symbol0 ">" @R [";"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["<"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["=>"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["=>?"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["=>@L"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["=>@R"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["@L"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["@R"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["Id"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["if"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["("]
    //   Symbol1 = @L (*) SymbolKind1 @R ["*"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["+"]
    //   Symbol1 = @L (*) SymbolKind1 @R [";"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["<"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["=>"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["=>?"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["=>@L"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["=>@R"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["?"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["@L"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["@R"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["Escape"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["Id"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["MacroId"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["StringLiteral"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["if"]
    //   SymbolKind1 = (*) Escape ["("]
    //   SymbolKind1 = (*) Escape ["*"]
    //   SymbolKind1 = (*) Escape ["+"]
    //   SymbolKind1 = (*) Escape [";"]
    //   SymbolKind1 = (*) Escape ["<"]
    //   SymbolKind1 = (*) Escape ["=>"]
    //   SymbolKind1 = (*) Escape ["=>?"]
    //   SymbolKind1 = (*) Escape ["=>@L"]
    //   SymbolKind1 = (*) Escape ["=>@R"]
    //   SymbolKind1 = (*) Escape ["?"]
    //   SymbolKind1 = (*) Escape ["@L"]
    //   SymbolKind1 = (*) Escape ["@R"]
    //   SymbolKind1 = (*) Escape ["Escape"]
    //   SymbolKind1 = (*) Escape ["Id"]
    //   SymbolKind1 = (*) Escape ["MacroId"]
    //   SymbolKind1 = (*) Escape ["StringLiteral"]
    //   SymbolKind1 = (*) Escape ["if"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["("]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" [";"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["<"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["=>"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["=>?"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["=>@L"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["=>@R"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["@L"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["@R"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["Escape"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["Id"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["MacroId"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["StringLiteral"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["if"]
    //   SymbolKind1 = (*) NonterminalId ["("]
    //   SymbolKind1 = (*) NonterminalId ["*"]
    //   SymbolKind1 = (*) NonterminalId ["+"]
    //   SymbolKind1 = (*) NonterminalId [";"]
    //   SymbolKind1 = (*) NonterminalId ["<"]
    //   SymbolKind1 = (*) NonterminalId ["=>"]
    //   SymbolKind1 = (*) NonterminalId ["=>?"]
    //   SymbolKind1 = (*) NonterminalId ["=>@L"]
    //   SymbolKind1 = (*) NonterminalId ["=>@R"]
    //   SymbolKind1 = (*) NonterminalId ["?"]
    //   SymbolKind1 = (*) NonterminalId ["@L"]
    //   SymbolKind1 = (*) NonterminalId ["@R"]
    //   SymbolKind1 = (*) NonterminalId ["Escape"]
    //   SymbolKind1 = (*) NonterminalId ["Id"]
    //   SymbolKind1 = (*) NonterminalId ["MacroId"]
    //   SymbolKind1 = (*) NonterminalId ["StringLiteral"]
    //   SymbolKind1 = (*) NonterminalId ["if"]
    //   SymbolKind1 = (*) Terminal ["("]
    //   SymbolKind1 = (*) Terminal ["*"]
    //   SymbolKind1 = (*) Terminal ["+"]
    //   SymbolKind1 = (*) Terminal [";"]
    //   SymbolKind1 = (*) Terminal ["<"]
    //   SymbolKind1 = (*) Terminal ["=>"]
    //   SymbolKind1 = (*) Terminal ["=>?"]
    //   SymbolKind1 = (*) Terminal ["=>@L"]
    //   SymbolKind1 = (*) Terminal ["=>@R"]
    //   SymbolKind1 = (*) Terminal ["?"]
    //   SymbolKind1 = (*) Terminal ["@L"]
    //   SymbolKind1 = (*) Terminal ["@R"]
    //   SymbolKind1 = (*) Terminal ["Escape"]
    //   SymbolKind1 = (*) Terminal ["Id"]
    //   SymbolKind1 = (*) Terminal ["MacroId"]
    //   SymbolKind1 = (*) Terminal ["StringLiteral"]
    //   SymbolKind1 = (*) Terminal ["if"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["("]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["*"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["+"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" [";"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["<"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["=>"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["=>?"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["=>@L"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["=>@R"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["?"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["@L"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["@R"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["Escape"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["Id"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["MacroId"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["StringLiteral"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["if"]
    //   SymbolKind1 = (*) "@L" ["("]
    //   SymbolKind1 = (*) "@L" ["*"]
    //   SymbolKind1 = (*) "@L" ["+"]
    //   SymbolKind1 = (*) "@L" [";"]
    //   SymbolKind1 = (*) "@L" ["<"]
    //   SymbolKind1 = (*) "@L" ["=>"]
    //   SymbolKind1 = (*) "@L" ["=>?"]
    //   SymbolKind1 = (*) "@L" ["=>@L"]
    //   SymbolKind1 = (*) "@L" ["=>@R"]
    //   SymbolKind1 = (*) "@L" ["?"]
    //   SymbolKind1 = (*) "@L" ["@L"]
    //   SymbolKind1 = (*) "@L" ["@R"]
    //   SymbolKind1 = (*) "@L" ["Escape"]
    //   SymbolKind1 = (*) "@L" ["Id"]
    //   SymbolKind1 = (*) "@L" ["MacroId"]
    //   SymbolKind1 = (*) "@L" ["StringLiteral"]
    //   SymbolKind1 = (*) "@L" ["if"]
    //   SymbolKind1 = (*) "@R" ["("]
    //   SymbolKind1 = (*) "@R" ["*"]
    //   SymbolKind1 = (*) "@R" ["+"]
    //   SymbolKind1 = (*) "@R" [";"]
    //   SymbolKind1 = (*) "@R" ["<"]
    //   SymbolKind1 = (*) "@R" ["=>"]
    //   SymbolKind1 = (*) "@R" ["=>?"]
    //   SymbolKind1 = (*) "@R" ["=>@L"]
    //   SymbolKind1 = (*) "@R" ["=>@R"]
    //   SymbolKind1 = (*) "@R" ["?"]
    //   SymbolKind1 = (*) "@R" ["@L"]
    //   SymbolKind1 = (*) "@R" ["@R"]
    //   SymbolKind1 = (*) "@R" ["Escape"]
    //   SymbolKind1 = (*) "@R" ["Id"]
    //   SymbolKind1 = (*) "@R" ["MacroId"]
    //   SymbolKind1 = (*) "@R" ["StringLiteral"]
    //   SymbolKind1 = (*) "@R" ["if"]
    //   Terminal = (*) StringLiteral ["("]
    //   Terminal = (*) StringLiteral ["*"]
    //   Terminal = (*) StringLiteral ["+"]
    //   Terminal = (*) StringLiteral [";"]
    //   Terminal = (*) StringLiteral ["<"]
    //   Terminal = (*) StringLiteral ["=>"]
    //   Terminal = (*) StringLiteral ["=>?"]
    //   Terminal = (*) StringLiteral ["=>@L"]
    //   Terminal = (*) StringLiteral ["=>@R"]
    //   Terminal = (*) StringLiteral ["?"]
    //   Terminal = (*) StringLiteral ["@L"]
    //   Terminal = (*) StringLiteral ["@R"]
    //   Terminal = (*) StringLiteral ["Escape"]
    //   Terminal = (*) StringLiteral ["Id"]
    //   Terminal = (*) StringLiteral ["MacroId"]
    //   Terminal = (*) StringLiteral ["StringLiteral"]
    //   Terminal = (*) StringLiteral ["if"]
    //
    //   "@R" -> Shift(S197)
    //   "(" -> Shift(S193)
    //   "StringLiteral" -> Shift(S192)
    //   "<" -> Shift(S201)
    //   "Escape" -> Shift(S191)
    //   "MacroId" -> Shift(S68)
    //   "@L" -> Shift(S194)
    //   "Id" -> Shift(S195)
    //
    //   StringLiteral -> S198
    //   SymbolKind1 -> S196
    //   NonterminalId -> S203
    //   Terminal -> S199
    //   MacroId -> S202
    //   Escape -> S200
    //   Id -> S190
    pub fn __state163<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Lookbehind(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state197(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state193(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::StringLiteral(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state192(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state201(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state191(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::MacroId(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Lookahead(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state194(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state195(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::StringLiteral(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state198(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::SymbolKind1(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state196(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state203(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Terminal(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state199(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::MacroId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state202(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state200(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state190(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 164
    //   Symbol0 = Symbol1 (*) ["("]
    //   Symbol0 = Symbol1 (*) ["*"]
    //   Symbol0 = Symbol1 (*) ["+"]
    //   Symbol0 = Symbol1 (*) [";"]
    //   Symbol0 = Symbol1 (*) ["<"]
    //   Symbol0 = Symbol1 (*) ["=>"]
    //   Symbol0 = Symbol1 (*) ["=>?"]
    //   Symbol0 = Symbol1 (*) ["=>@L"]
    //   Symbol0 = Symbol1 (*) ["=>@R"]
    //   Symbol0 = Symbol1 (*) ["?"]
    //   Symbol0 = Symbol1 (*) ["@L"]
    //   Symbol0 = Symbol1 (*) ["@R"]
    //   Symbol0 = Symbol1 (*) ["Escape"]
    //   Symbol0 = Symbol1 (*) ["Id"]
    //   Symbol0 = Symbol1 (*) ["MacroId"]
    //   Symbol0 = Symbol1 (*) ["StringLiteral"]
    //   Symbol0 = Symbol1 (*) ["if"]
    //
    //   "*" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "+" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "=>" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "=>@L" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "<" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "Escape" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "StringLiteral" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "MacroId" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   ";" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "@L" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "=>?" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "?" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "=>@R" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "if" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "Id" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "@R" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "(" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //
    pub fn __state164<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 165
    //   Symbol* = Symbol* Symbol (*) ["("]
    //   Symbol* = Symbol* Symbol (*) [";"]
    //   Symbol* = Symbol* Symbol (*) ["<"]
    //   Symbol* = Symbol* Symbol (*) ["=>"]
    //   Symbol* = Symbol* Symbol (*) ["=>?"]
    //   Symbol* = Symbol* Symbol (*) ["=>@L"]
    //   Symbol* = Symbol* Symbol (*) ["=>@R"]
    //   Symbol* = Symbol* Symbol (*) ["@L"]
    //   Symbol* = Symbol* Symbol (*) ["@R"]
    //   Symbol* = Symbol* Symbol (*) ["Escape"]
    //   Symbol* = Symbol* Symbol (*) ["Id"]
    //   Symbol* = Symbol* Symbol (*) ["MacroId"]
    //   Symbol* = Symbol* Symbol (*) ["StringLiteral"]
    //   Symbol* = Symbol* Symbol (*) ["if"]
    //
    //   "<" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "if" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "Id" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "=>@L" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "@L" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "Escape" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "=>?" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "=>" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "@R" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "(" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   ";" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "MacroId" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "StringLiteral" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "=>@R" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //
    pub fn __state165<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Symbol>>,
        __sym1: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 166
    //   Alternative* = Alternative* Alternative (*) ["("]
    //   Alternative* = Alternative* Alternative (*) [";"]
    //   Alternative* = Alternative* Alternative (*) ["<"]
    //   Alternative* = Alternative* Alternative (*) ["=>"]
    //   Alternative* = Alternative* Alternative (*) ["=>?"]
    //   Alternative* = Alternative* Alternative (*) ["=>@L"]
    //   Alternative* = Alternative* Alternative (*) ["=>@R"]
    //   Alternative* = Alternative* Alternative (*) ["@L"]
    //   Alternative* = Alternative* Alternative (*) ["@R"]
    //   Alternative* = Alternative* Alternative (*) ["Escape"]
    //   Alternative* = Alternative* Alternative (*) ["Id"]
    //   Alternative* = Alternative* Alternative (*) ["MacroId"]
    //   Alternative* = Alternative* Alternative (*) ["StringLiteral"]
    //   Alternative* = Alternative* Alternative (*) ["if"]
    //   Alternative* = Alternative* Alternative (*) ["}"]
    //
    //   "=>" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "=>?" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "StringLiteral" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "<" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "@L" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "MacroId" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "(" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "=>@L" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "}" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "@R" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "Escape" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "if" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "=>@R" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   ";" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //   "Id" -> Reduce(Alternative* = Alternative*, Alternative => Call(ActionFn(102));)
    //
    pub fn __state166<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Alternative>>,
        __sym1: &mut Option<Alternative>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action102(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 167
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["("]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R [";"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["<"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["=>"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["=>?"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["=>@L"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["=>@R"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["@L"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["@R"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["Escape"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["Id"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["MacroId"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["StringLiteral"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["if"]
    //   Alternative = @L (*) ExprSymbol ("if" <Cond>)? Action? ";" @R ["}"]
    //   ExprSymbol = (*) Symbol* [";"]
    //   ExprSymbol = (*) Symbol* ["=>"]
    //   ExprSymbol = (*) Symbol* ["=>?"]
    //   ExprSymbol = (*) Symbol* ["=>@L"]
    //   ExprSymbol = (*) Symbol* ["=>@R"]
    //   ExprSymbol = (*) Symbol* ["if"]
    //   Symbol* = (*) ["("]
    //   Symbol* = (*) [";"]
    //   Symbol* = (*) ["<"]
    //   Symbol* = (*) ["=>"]
    //   Symbol* = (*) ["=>?"]
    //   Symbol* = (*) ["=>@L"]
    //   Symbol* = (*) ["=>@R"]
    //   Symbol* = (*) ["@L"]
    //   Symbol* = (*) ["@R"]
    //   Symbol* = (*) ["Escape"]
    //   Symbol* = (*) ["Id"]
    //   Symbol* = (*) ["MacroId"]
    //   Symbol* = (*) ["StringLiteral"]
    //   Symbol* = (*) ["if"]
    //   Symbol* = (*) Symbol* Symbol ["("]
    //   Symbol* = (*) Symbol* Symbol [";"]
    //   Symbol* = (*) Symbol* Symbol ["<"]
    //   Symbol* = (*) Symbol* Symbol ["=>"]
    //   Symbol* = (*) Symbol* Symbol ["=>?"]
    //   Symbol* = (*) Symbol* Symbol ["=>@L"]
    //   Symbol* = (*) Symbol* Symbol ["=>@R"]
    //   Symbol* = (*) Symbol* Symbol ["@L"]
    //   Symbol* = (*) Symbol* Symbol ["@R"]
    //   Symbol* = (*) Symbol* Symbol ["Escape"]
    //   Symbol* = (*) Symbol* Symbol ["Id"]
    //   Symbol* = (*) Symbol* Symbol ["MacroId"]
    //   Symbol* = (*) Symbol* Symbol ["StringLiteral"]
    //   Symbol* = (*) Symbol* Symbol ["if"]
    //
    //   "@R" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "=>@R" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "StringLiteral" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Id" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "<" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "=>" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "if" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "=>@L" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Escape" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "=>?" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   ";" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@L" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "(" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "MacroId" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //
    //   Symbol* -> S153
    //   ExprSymbol -> S204
    pub fn __state167<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state153(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::ExprSymbol(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state204(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 168
    //   Alternatives = "{" Alternative* "}" (*) ";" [EOF]
    //   Alternatives = "{" Alternative* "}" (*) ";" ["Escape"]
    //   Alternatives = "{" Alternative* "}" (*) ";" ["Id"]
    //   Alternatives = "{" Alternative* "}" (*) ";" ["MacroId"]
    //   Alternatives = "{" Alternative* "}" (*) ";" ["extern"]
    //   Alternatives = "{" Alternative* "}" (*) ";" ["pub"]
    //   Alternatives = "{" Alternative* "}" (*) ";" ["use"]
    //
    //   ";" -> Shift(S205)
    //
    pub fn __state168<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::vec::Vec<Alternative>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Semi(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state205(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 169
    //   TypeRef = Path (*) ["{"]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" ["{"]
    //
    //   "<" -> Shift(S206)
    //   "{" -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //
    pub fn __state169<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state206(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 170
    //   Escape = "Escape" (*) ["{"]
    //
    //   "{" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state170<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 171
    //   (<TypeRef> ",")* = (*) ["&"]
    //   (<TypeRef> ",")* = (*) ["("]
    //   (<TypeRef> ",")* = (*) [")"]
    //   (<TypeRef> ",")* = (*) ["::"]
    //   (<TypeRef> ",")* = (*) ["Escape"]
    //   (<TypeRef> ",")* = (*) ["Id"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (*) (<TypeRef> ",")* TypeRef? [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" ["{"]
    //
    //   "::" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Id" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "(" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "&" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Escape" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   ")" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //
    //   Comma<TypeRef> -> S207
    //   (<TypeRef> ",")* -> S60
    pub fn __state171<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRef_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state207(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state60(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 172
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id ["<"]
    //   Path = "::"? (*) (<Id> "::")* Id ["{"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S208
    pub fn __state172<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state208(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 173
    //   TypeRef = Escape (*) ["{"]
    //
    //   "{" -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //
    pub fn __state173<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 174
    //   @R = (*) ["{"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef (*) @R "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef (*) @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef (*) @R "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef (*) @R "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef (*) @R "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef (*) @R "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef (*) @R "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "{" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S209
    pub fn __state174<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
        __sym8: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftBrace(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym8.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym9 = &mut Some(__nt);
                    __result = try!(__state209(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 175
    //   Lifetime = (*) "Lifetime" ["&"]
    //   Lifetime = (*) "Lifetime" ["("]
    //   Lifetime = (*) "Lifetime" ["::"]
    //   Lifetime = (*) "Lifetime" ["Escape"]
    //   Lifetime = (*) "Lifetime" ["Id"]
    //   Lifetime = (*) "Lifetime" ["mut"]
    //   Lifetime? = (*) ["&"]
    //   Lifetime? = (*) ["("]
    //   Lifetime? = (*) ["::"]
    //   Lifetime? = (*) ["Escape"]
    //   Lifetime? = (*) ["Id"]
    //   Lifetime? = (*) ["mut"]
    //   Lifetime? = (*) Lifetime ["&"]
    //   Lifetime? = (*) Lifetime ["("]
    //   Lifetime? = (*) Lifetime ["::"]
    //   Lifetime? = (*) Lifetime ["Escape"]
    //   Lifetime? = (*) Lifetime ["Id"]
    //   Lifetime? = (*) Lifetime ["mut"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef ["{"]
    //
    //   "Escape" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "::" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "mut" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Lifetime" -> Shift(S58)
    //   "(" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Id" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "&" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //
    //   Lifetime -> S59
    //   Lifetime? -> S210
    pub fn __state175<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state58(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state59(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Lifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state210(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 176
    //   Id = "Id" (*) ["="]
    //
    //   "=" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state176<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 177
    //   @R = (*) ["="]
    //   AssociatedType = "type" @L Id (*) @R "=" TypeRef ";" ["enum"]
    //   AssociatedType = "type" @L Id (*) @R "=" TypeRef ";" ["type"]
    //
    //   "=" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S211
    pub fn __state177<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state211(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 178
    //   Cond = @L (*) NonterminalId CondOp StringLiteral @R [";"]
    //   Cond = @L (*) NonterminalId CondOp StringLiteral @R ["=>"]
    //   Cond = @L (*) NonterminalId CondOp StringLiteral @R ["=>?"]
    //   Cond = @L (*) NonterminalId CondOp StringLiteral @R ["=>@L"]
    //   Cond = @L (*) NonterminalId CondOp StringLiteral @R ["=>@R"]
    //   Id = (*) "Id" ["!="]
    //   Id = (*) "Id" ["!~"]
    //   Id = (*) "Id" ["=="]
    //   Id = (*) "Id" ["~~"]
    //   NonterminalId = (*) Id ["!="]
    //   NonterminalId = (*) Id ["!~"]
    //   NonterminalId = (*) Id ["=="]
    //   NonterminalId = (*) Id ["~~"]
    //
    //   "Id" -> Shift(S213)
    //
    //   Id -> S214
    //   NonterminalId -> S212
    pub fn __state178<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state213(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state214(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state212(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 179
    //   ("if" <Cond>) = "if" Cond (*) [";"]
    //   ("if" <Cond>) = "if" Cond (*) ["=>"]
    //   ("if" <Cond>) = "if" Cond (*) ["=>?"]
    //   ("if" <Cond>) = "if" Cond (*) ["=>@L"]
    //   ("if" <Cond>) = "if" Cond (*) ["=>@R"]
    //
    //   "=>@R" -> Reduce(("if" <Cond>) = "if", Cond => Call(ActionFn(100));)
    //   "=>" -> Reduce(("if" <Cond>) = "if", Cond => Call(ActionFn(100));)
    //   ";" -> Reduce(("if" <Cond>) = "if", Cond => Call(ActionFn(100));)
    //   "=>@L" -> Reduce(("if" <Cond>) = "if", Cond => Call(ActionFn(100));)
    //   "=>?" -> Reduce(("if" <Cond>) = "if", Cond => Call(ActionFn(100));)
    //
    pub fn __state179<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Condition>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action100(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action100(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action100(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action100(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action100(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 180
    //   Action = "=>@R" (*) [";"]
    //
    //   ";" -> Reduce(Action = "=>@R" => Call(ActionFn(20));)
    //
    pub fn __state180<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action20(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Action(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 181
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R [EOF]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["Escape"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["Id"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["MacroId"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["extern"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["pub"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["use"]
    //
    //   ";" -> Shift(S215)
    //
    pub fn __state181<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<::std::option::Option<Condition>>,
        __sym3: &mut Option<::std::option::Option<ActionKind>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Semi(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state215(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 182
    //   Action? = Action (*) [";"]
    //
    //   ";" -> Reduce(Action? = Action => Call(ActionFn(96));)
    //
    pub fn __state182<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<ActionKind>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action96(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Action_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 183
    //   Action = "=>?" (*) [";"]
    //
    //   ";" -> Reduce(Action = "=>?" => Call(ActionFn(22));)
    //
    pub fn __state183<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action22(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Action(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 184
    //   Action = "=>" (*) [";"]
    //
    //   ";" -> Reduce(Action = "=>" => Call(ActionFn(21));)
    //
    pub fn __state184<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action21(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Action(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 185
    //   Action = "=>@L" (*) [";"]
    //
    //   ";" -> Reduce(Action = "=>@L" => Call(ActionFn(19));)
    //
    pub fn __state185<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action19(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Action(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 186
    //   RepeatOp = "*" (*) ["("]
    //   RepeatOp = "*" (*) ["*"]
    //   RepeatOp = "*" (*) ["+"]
    //   RepeatOp = "*" (*) [";"]
    //   RepeatOp = "*" (*) ["<"]
    //   RepeatOp = "*" (*) ["=>"]
    //   RepeatOp = "*" (*) ["=>?"]
    //   RepeatOp = "*" (*) ["=>@L"]
    //   RepeatOp = "*" (*) ["=>@R"]
    //   RepeatOp = "*" (*) ["?"]
    //   RepeatOp = "*" (*) ["@L"]
    //   RepeatOp = "*" (*) ["@R"]
    //   RepeatOp = "*" (*) ["Escape"]
    //   RepeatOp = "*" (*) ["Id"]
    //   RepeatOp = "*" (*) ["MacroId"]
    //   RepeatOp = "*" (*) ["StringLiteral"]
    //   RepeatOp = "*" (*) ["if"]
    //
    //   "if" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "=>?" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "@L" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   ";" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "@R" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "<" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "+" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "=>" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "Escape" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "Id" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "StringLiteral" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "=>@R" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "?" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "=>@L" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "(" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "*" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "MacroId" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //
    pub fn __state186<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 187
    //   RepeatOp = "?" (*) ["("]
    //   RepeatOp = "?" (*) ["*"]
    //   RepeatOp = "?" (*) ["+"]
    //   RepeatOp = "?" (*) [";"]
    //   RepeatOp = "?" (*) ["<"]
    //   RepeatOp = "?" (*) ["=>"]
    //   RepeatOp = "?" (*) ["=>?"]
    //   RepeatOp = "?" (*) ["=>@L"]
    //   RepeatOp = "?" (*) ["=>@R"]
    //   RepeatOp = "?" (*) ["?"]
    //   RepeatOp = "?" (*) ["@L"]
    //   RepeatOp = "?" (*) ["@R"]
    //   RepeatOp = "?" (*) ["Escape"]
    //   RepeatOp = "?" (*) ["Id"]
    //   RepeatOp = "?" (*) ["MacroId"]
    //   RepeatOp = "?" (*) ["StringLiteral"]
    //   RepeatOp = "?" (*) ["if"]
    //
    //   "StringLiteral" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "if" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "=>@L" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "MacroId" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "Escape" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   ";" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "@L" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "(" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "<" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "=>" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "?" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "=>@R" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "*" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "+" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "Id" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "=>?" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "@R" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //
    pub fn __state187<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 188
    //   RepeatOp = "+" (*) ["("]
    //   RepeatOp = "+" (*) ["*"]
    //   RepeatOp = "+" (*) ["+"]
    //   RepeatOp = "+" (*) [";"]
    //   RepeatOp = "+" (*) ["<"]
    //   RepeatOp = "+" (*) ["=>"]
    //   RepeatOp = "+" (*) ["=>?"]
    //   RepeatOp = "+" (*) ["=>@L"]
    //   RepeatOp = "+" (*) ["=>@R"]
    //   RepeatOp = "+" (*) ["?"]
    //   RepeatOp = "+" (*) ["@L"]
    //   RepeatOp = "+" (*) ["@R"]
    //   RepeatOp = "+" (*) ["Escape"]
    //   RepeatOp = "+" (*) ["Id"]
    //   RepeatOp = "+" (*) ["MacroId"]
    //   RepeatOp = "+" (*) ["StringLiteral"]
    //   RepeatOp = "+" (*) ["if"]
    //
    //   "=>" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "?" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "+" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "Escape" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "Id" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "*" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "@L" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "if" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   ";" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "=>?" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "(" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "MacroId" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "=>@L" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "<" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "=>@R" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "@R" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "StringLiteral" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //
    pub fn __state188<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 189
    //   @R = (*) ["("]
    //   @R = (*) ["*"]
    //   @R = (*) ["+"]
    //   @R = (*) [";"]
    //   @R = (*) ["<"]
    //   @R = (*) ["=>"]
    //   @R = (*) ["=>?"]
    //   @R = (*) ["=>@L"]
    //   @R = (*) ["=>@R"]
    //   @R = (*) ["?"]
    //   @R = (*) ["@L"]
    //   @R = (*) ["@R"]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["StringLiteral"]
    //   @R = (*) ["if"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["("]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["*"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["+"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R [";"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["<"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["=>"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["=>?"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["=>@L"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["=>@R"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["?"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["@L"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["@R"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["Escape"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["Id"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["MacroId"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["StringLiteral"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["if"]
    //
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //   "=>" -> Reduce(@R =  => Lookbehind;)
    //   "*" -> Reduce(@R =  => Lookbehind;)
    //   "+" -> Reduce(@R =  => Lookbehind;)
    //   "StringLiteral" -> Reduce(@R =  => Lookbehind;)
    //   "?" -> Reduce(@R =  => Lookbehind;)
    //   "@L" -> Reduce(@R =  => Lookbehind;)
    //   "@R" -> Reduce(@R =  => Lookbehind;)
    //   ";" -> Reduce(@R =  => Lookbehind;)
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   "=>@R" -> Reduce(@R =  => Lookbehind;)
    //   "=>@L" -> Reduce(@R =  => Lookbehind;)
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //   "if" -> Reduce(@R =  => Lookbehind;)
    //   "=>?" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S216
    pub fn __state189<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
        __sym1: &mut Option<RepeatOp>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Star(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Question(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state216(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 190
    //   NonterminalId = Id (*) ["("]
    //   NonterminalId = Id (*) ["*"]
    //   NonterminalId = Id (*) ["+"]
    //   NonterminalId = Id (*) [";"]
    //   NonterminalId = Id (*) ["<"]
    //   NonterminalId = Id (*) ["=>"]
    //   NonterminalId = Id (*) ["=>?"]
    //   NonterminalId = Id (*) ["=>@L"]
    //   NonterminalId = Id (*) ["=>@R"]
    //   NonterminalId = Id (*) ["?"]
    //   NonterminalId = Id (*) ["@L"]
    //   NonterminalId = Id (*) ["@R"]
    //   NonterminalId = Id (*) ["Escape"]
    //   NonterminalId = Id (*) ["Id"]
    //   NonterminalId = Id (*) ["MacroId"]
    //   NonterminalId = Id (*) ["StringLiteral"]
    //   NonterminalId = Id (*) ["if"]
    //
    //   "*" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "=>" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "=>@L" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "@L" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "=>?" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "MacroId" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "+" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "if" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   ";" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "@R" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "Id" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "<" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "?" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "StringLiteral" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "=>@R" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "(" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "Escape" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //
    pub fn __state190<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 191
    //   Escape = "Escape" (*) ["("]
    //   Escape = "Escape" (*) ["*"]
    //   Escape = "Escape" (*) ["+"]
    //   Escape = "Escape" (*) [";"]
    //   Escape = "Escape" (*) ["<"]
    //   Escape = "Escape" (*) ["=>"]
    //   Escape = "Escape" (*) ["=>?"]
    //   Escape = "Escape" (*) ["=>@L"]
    //   Escape = "Escape" (*) ["=>@R"]
    //   Escape = "Escape" (*) ["?"]
    //   Escape = "Escape" (*) ["@L"]
    //   Escape = "Escape" (*) ["@R"]
    //   Escape = "Escape" (*) ["Escape"]
    //   Escape = "Escape" (*) ["Id"]
    //   Escape = "Escape" (*) ["MacroId"]
    //   Escape = "Escape" (*) ["StringLiteral"]
    //   Escape = "Escape" (*) ["if"]
    //
    //   "+" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "=>" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "=>@R" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "if" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "Id" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "(" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "=>@L" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "MacroId" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "?" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "StringLiteral" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "*" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   ";" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "=>?" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "@R" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "@L" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "Escape" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "<" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state191<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 192
    //   StringLiteral = "StringLiteral" (*) ["("]
    //   StringLiteral = "StringLiteral" (*) ["*"]
    //   StringLiteral = "StringLiteral" (*) ["+"]
    //   StringLiteral = "StringLiteral" (*) [";"]
    //   StringLiteral = "StringLiteral" (*) ["<"]
    //   StringLiteral = "StringLiteral" (*) ["=>"]
    //   StringLiteral = "StringLiteral" (*) ["=>?"]
    //   StringLiteral = "StringLiteral" (*) ["=>@L"]
    //   StringLiteral = "StringLiteral" (*) ["=>@R"]
    //   StringLiteral = "StringLiteral" (*) ["?"]
    //   StringLiteral = "StringLiteral" (*) ["@L"]
    //   StringLiteral = "StringLiteral" (*) ["@R"]
    //   StringLiteral = "StringLiteral" (*) ["Escape"]
    //   StringLiteral = "StringLiteral" (*) ["Id"]
    //   StringLiteral = "StringLiteral" (*) ["MacroId"]
    //   StringLiteral = "StringLiteral" (*) ["StringLiteral"]
    //   StringLiteral = "StringLiteral" (*) ["if"]
    //
    //   "StringLiteral" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "(" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "@L" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "@R" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "?" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "=>" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "MacroId" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "*" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "=>@L" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "if" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "Escape" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "=>@R" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   ";" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "+" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "Id" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "<" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "=>?" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //
    pub fn __state192<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 193
    //   ExprSymbol = (*) Symbol* [")"]
    //   Symbol* = (*) ["("]
    //   Symbol* = (*) [")"]
    //   Symbol* = (*) ["<"]
    //   Symbol* = (*) ["@L"]
    //   Symbol* = (*) ["@R"]
    //   Symbol* = (*) ["Escape"]
    //   Symbol* = (*) ["Id"]
    //   Symbol* = (*) ["MacroId"]
    //   Symbol* = (*) ["StringLiteral"]
    //   Symbol* = (*) Symbol* Symbol ["("]
    //   Symbol* = (*) Symbol* Symbol [")"]
    //   Symbol* = (*) Symbol* Symbol ["<"]
    //   Symbol* = (*) Symbol* Symbol ["@L"]
    //   Symbol* = (*) Symbol* Symbol ["@R"]
    //   Symbol* = (*) Symbol* Symbol ["Escape"]
    //   Symbol* = (*) Symbol* Symbol ["Id"]
    //   Symbol* = (*) Symbol* Symbol ["MacroId"]
    //   Symbol* = (*) Symbol* Symbol ["StringLiteral"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["("]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["*"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["+"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" [";"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["<"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["=>"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["=>?"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["=>@L"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["=>@R"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["?"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["@L"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["@R"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["Escape"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["Id"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["MacroId"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["StringLiteral"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["if"]
    //
    //   ")" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Id" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "(" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@L" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "StringLiteral" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "<" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "MacroId" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@R" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Escape" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //
    //   Symbol* -> S218
    //   ExprSymbol -> S217
    pub fn __state193<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state218(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::ExprSymbol(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state217(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 194
    //   SymbolKind1 = "@L" (*) ["("]
    //   SymbolKind1 = "@L" (*) ["*"]
    //   SymbolKind1 = "@L" (*) ["+"]
    //   SymbolKind1 = "@L" (*) [";"]
    //   SymbolKind1 = "@L" (*) ["<"]
    //   SymbolKind1 = "@L" (*) ["=>"]
    //   SymbolKind1 = "@L" (*) ["=>?"]
    //   SymbolKind1 = "@L" (*) ["=>@L"]
    //   SymbolKind1 = "@L" (*) ["=>@R"]
    //   SymbolKind1 = "@L" (*) ["?"]
    //   SymbolKind1 = "@L" (*) ["@L"]
    //   SymbolKind1 = "@L" (*) ["@R"]
    //   SymbolKind1 = "@L" (*) ["Escape"]
    //   SymbolKind1 = "@L" (*) ["Id"]
    //   SymbolKind1 = "@L" (*) ["MacroId"]
    //   SymbolKind1 = "@L" (*) ["StringLiteral"]
    //   SymbolKind1 = "@L" (*) ["if"]
    //
    //   "=>@L" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "<" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "if" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "MacroId" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "@L" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "@R" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "?" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "(" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "Escape" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "Id" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "+" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "=>" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "*" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "=>?" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   ";" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "=>@R" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //
    pub fn __state194<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 195
    //   Id = "Id" (*) ["("]
    //   Id = "Id" (*) ["*"]
    //   Id = "Id" (*) ["+"]
    //   Id = "Id" (*) [";"]
    //   Id = "Id" (*) ["<"]
    //   Id = "Id" (*) ["=>"]
    //   Id = "Id" (*) ["=>?"]
    //   Id = "Id" (*) ["=>@L"]
    //   Id = "Id" (*) ["=>@R"]
    //   Id = "Id" (*) ["?"]
    //   Id = "Id" (*) ["@L"]
    //   Id = "Id" (*) ["@R"]
    //   Id = "Id" (*) ["Escape"]
    //   Id = "Id" (*) ["Id"]
    //   Id = "Id" (*) ["MacroId"]
    //   Id = "Id" (*) ["StringLiteral"]
    //   Id = "Id" (*) ["if"]
    //
    //   ";" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "@L" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "=>" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "StringLiteral" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "@R" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "?" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "=>@R" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "Escape" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "Id" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "if" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "*" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "=>?" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "MacroId" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "+" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "=>@L" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "(" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state195<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 196
    //   @R = (*) ["("]
    //   @R = (*) ["*"]
    //   @R = (*) ["+"]
    //   @R = (*) [";"]
    //   @R = (*) ["<"]
    //   @R = (*) ["=>"]
    //   @R = (*) ["=>?"]
    //   @R = (*) ["=>@L"]
    //   @R = (*) ["=>@R"]
    //   @R = (*) ["?"]
    //   @R = (*) ["@L"]
    //   @R = (*) ["@R"]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["StringLiteral"]
    //   @R = (*) ["if"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["("]
    //   Symbol1 = @L SymbolKind1 (*) @R ["*"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["+"]
    //   Symbol1 = @L SymbolKind1 (*) @R [";"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["<"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["=>"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["=>?"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["=>@L"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["=>@R"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["?"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["@L"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["@R"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["Escape"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["Id"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["MacroId"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["StringLiteral"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["if"]
    //
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //   "@L" -> Reduce(@R =  => Lookbehind;)
    //   "StringLiteral" -> Reduce(@R =  => Lookbehind;)
    //   "?" -> Reduce(@R =  => Lookbehind;)
    //   "*" -> Reduce(@R =  => Lookbehind;)
    //   "+" -> Reduce(@R =  => Lookbehind;)
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //   "@R" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   "=>?" -> Reduce(@R =  => Lookbehind;)
    //   "=>@R" -> Reduce(@R =  => Lookbehind;)
    //   "=>@L" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //   "=>" -> Reduce(@R =  => Lookbehind;)
    //   "if" -> Reduce(@R =  => Lookbehind;)
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   ";" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S219
    pub fn __state196<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<SymbolKind>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Question(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Star(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state219(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 197
    //   SymbolKind1 = "@R" (*) ["("]
    //   SymbolKind1 = "@R" (*) ["*"]
    //   SymbolKind1 = "@R" (*) ["+"]
    //   SymbolKind1 = "@R" (*) [";"]
    //   SymbolKind1 = "@R" (*) ["<"]
    //   SymbolKind1 = "@R" (*) ["=>"]
    //   SymbolKind1 = "@R" (*) ["=>?"]
    //   SymbolKind1 = "@R" (*) ["=>@L"]
    //   SymbolKind1 = "@R" (*) ["=>@R"]
    //   SymbolKind1 = "@R" (*) ["?"]
    //   SymbolKind1 = "@R" (*) ["@L"]
    //   SymbolKind1 = "@R" (*) ["@R"]
    //   SymbolKind1 = "@R" (*) ["Escape"]
    //   SymbolKind1 = "@R" (*) ["Id"]
    //   SymbolKind1 = "@R" (*) ["MacroId"]
    //   SymbolKind1 = "@R" (*) ["StringLiteral"]
    //   SymbolKind1 = "@R" (*) ["if"]
    //
    //   "=>?" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "*" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "+" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "Escape" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   ";" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "@R" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "Id" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "MacroId" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "@L" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "(" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "=>" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "<" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "?" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "=>@L" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "if" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "=>@R" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //
    pub fn __state197<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 198
    //   Terminal = StringLiteral (*) ["("]
    //   Terminal = StringLiteral (*) ["*"]
    //   Terminal = StringLiteral (*) ["+"]
    //   Terminal = StringLiteral (*) [";"]
    //   Terminal = StringLiteral (*) ["<"]
    //   Terminal = StringLiteral (*) ["=>"]
    //   Terminal = StringLiteral (*) ["=>?"]
    //   Terminal = StringLiteral (*) ["=>@L"]
    //   Terminal = StringLiteral (*) ["=>@R"]
    //   Terminal = StringLiteral (*) ["?"]
    //   Terminal = StringLiteral (*) ["@L"]
    //   Terminal = StringLiteral (*) ["@R"]
    //   Terminal = StringLiteral (*) ["Escape"]
    //   Terminal = StringLiteral (*) ["Id"]
    //   Terminal = StringLiteral (*) ["MacroId"]
    //   Terminal = StringLiteral (*) ["StringLiteral"]
    //   Terminal = StringLiteral (*) ["if"]
    //
    //   "Escape" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "MacroId" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "=>@L" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "=>?" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "if" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "*" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "Id" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "(" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   ";" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "@L" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "=>@R" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "StringLiteral" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "@R" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "+" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "<" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "?" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "=>" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //
    pub fn __state198<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 199
    //   SymbolKind1 = Terminal (*) ["("]
    //   SymbolKind1 = Terminal (*) ["*"]
    //   SymbolKind1 = Terminal (*) ["+"]
    //   SymbolKind1 = Terminal (*) [";"]
    //   SymbolKind1 = Terminal (*) ["<"]
    //   SymbolKind1 = Terminal (*) ["=>"]
    //   SymbolKind1 = Terminal (*) ["=>?"]
    //   SymbolKind1 = Terminal (*) ["=>@L"]
    //   SymbolKind1 = Terminal (*) ["=>@R"]
    //   SymbolKind1 = Terminal (*) ["?"]
    //   SymbolKind1 = Terminal (*) ["@L"]
    //   SymbolKind1 = Terminal (*) ["@R"]
    //   SymbolKind1 = Terminal (*) ["Escape"]
    //   SymbolKind1 = Terminal (*) ["Id"]
    //   SymbolKind1 = Terminal (*) ["MacroId"]
    //   SymbolKind1 = Terminal (*) ["StringLiteral"]
    //   SymbolKind1 = Terminal (*) ["if"]
    //
    //   "?" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "MacroId" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "<" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "Escape" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "=>@L" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "*" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "=>" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "Id" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   ";" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "if" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "=>@R" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "=>?" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "@L" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "@R" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "+" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "(" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //
    pub fn __state199<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TerminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 200
    //   SymbolKind1 = Escape (*) ["("]
    //   SymbolKind1 = Escape (*) ["*"]
    //   SymbolKind1 = Escape (*) ["+"]
    //   SymbolKind1 = Escape (*) [";"]
    //   SymbolKind1 = Escape (*) ["<"]
    //   SymbolKind1 = Escape (*) ["=>"]
    //   SymbolKind1 = Escape (*) ["=>?"]
    //   SymbolKind1 = Escape (*) ["=>@L"]
    //   SymbolKind1 = Escape (*) ["=>@R"]
    //   SymbolKind1 = Escape (*) ["?"]
    //   SymbolKind1 = Escape (*) ["@L"]
    //   SymbolKind1 = Escape (*) ["@R"]
    //   SymbolKind1 = Escape (*) ["Escape"]
    //   SymbolKind1 = Escape (*) ["Id"]
    //   SymbolKind1 = Escape (*) ["MacroId"]
    //   SymbolKind1 = Escape (*) ["StringLiteral"]
    //   SymbolKind1 = Escape (*) ["if"]
    //
    //   "StringLiteral" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "Escape" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "@L" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "if" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "Id" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "=>" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "=>@L" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "*" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "+" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "=>?" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "<" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "=>@R" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "(" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "?" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "MacroId" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   ";" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "@R" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //
    pub fn __state200<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 201
    //   @L = (*) ["("]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["("]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R [";"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["=>"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["=>?"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["=>@L"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["=>@R"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["if"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["("]
    //   Symbol = @L "<" (*) Symbol0 ">" @R [";"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["=>"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["=>?"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["=>@L"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["=>@R"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["if"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["*"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["+"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["?"]
    //   Symbol0 = (*) Symbol1 ["*"]
    //   Symbol0 = (*) Symbol1 ["+"]
    //   Symbol0 = (*) Symbol1 [">"]
    //   Symbol0 = (*) Symbol1 ["?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["*"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["+"]
    //   Symbol1 = (*) @L SymbolKind1 @R [">"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["?"]
    //
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //
    //   Symbol1 -> S220
    //   @L -> S221
    //   Symbol0 -> S222
    pub fn __state201<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol1(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state220(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state221(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::Symbol0(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state222(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 202
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["("]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" [";"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["<"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["=>"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["=>?"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["=>@L"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["=>@R"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["@L"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["@R"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["Escape"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["Id"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["MacroId"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["StringLiteral"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["if"]
    //
    //   "<" -> Shift(S223)
    //
    pub fn __state202<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state223(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 203
    //   SymbolKind1 = NonterminalId (*) ["("]
    //   SymbolKind1 = NonterminalId (*) ["*"]
    //   SymbolKind1 = NonterminalId (*) ["+"]
    //   SymbolKind1 = NonterminalId (*) [";"]
    //   SymbolKind1 = NonterminalId (*) ["<"]
    //   SymbolKind1 = NonterminalId (*) ["=>"]
    //   SymbolKind1 = NonterminalId (*) ["=>?"]
    //   SymbolKind1 = NonterminalId (*) ["=>@L"]
    //   SymbolKind1 = NonterminalId (*) ["=>@R"]
    //   SymbolKind1 = NonterminalId (*) ["?"]
    //   SymbolKind1 = NonterminalId (*) ["@L"]
    //   SymbolKind1 = NonterminalId (*) ["@R"]
    //   SymbolKind1 = NonterminalId (*) ["Escape"]
    //   SymbolKind1 = NonterminalId (*) ["Id"]
    //   SymbolKind1 = NonterminalId (*) ["MacroId"]
    //   SymbolKind1 = NonterminalId (*) ["StringLiteral"]
    //   SymbolKind1 = NonterminalId (*) ["if"]
    //
    //   "=>?" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "=>@R" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "=>" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "Escape" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "+" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "Id" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "?" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "<" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "=>@L" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "@L" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   ";" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "MacroId" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "if" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "(" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "*" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "@R" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //
    pub fn __state203<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 204
    //   ("if" <Cond>) = (*) "if" Cond [";"]
    //   ("if" <Cond>) = (*) "if" Cond ["=>"]
    //   ("if" <Cond>) = (*) "if" Cond ["=>?"]
    //   ("if" <Cond>) = (*) "if" Cond ["=>@L"]
    //   ("if" <Cond>) = (*) "if" Cond ["=>@R"]
    //   ("if" <Cond>)? = (*) [";"]
    //   ("if" <Cond>)? = (*) ["=>"]
    //   ("if" <Cond>)? = (*) ["=>?"]
    //   ("if" <Cond>)? = (*) ["=>@L"]
    //   ("if" <Cond>)? = (*) ["=>@R"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) [";"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) ["=>"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) ["=>?"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) ["=>@L"]
    //   ("if" <Cond>)? = (*) ("if" <Cond>) ["=>@R"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["("]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R [";"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["<"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["=>"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["=>?"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["=>@L"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["=>@R"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["@L"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["@R"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["Escape"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["Id"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["MacroId"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["StringLiteral"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["if"]
    //   Alternative = @L ExprSymbol (*) ("if" <Cond>)? Action? ";" @R ["}"]
    //
    //   "=>@L" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //   "if" -> Shift(S160)
    //   "=>?" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //   "=>" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //   "=>@R" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //   ";" -> Reduce(("if" <Cond>)? =  => Call(ActionFn(99));)
    //
    //   ("if" <Cond>)? -> S224
    //   ("if" <Cond>) -> S159
    pub fn __state204<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::If(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state160(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action99(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_22if_22_20_3cCond_3e_29_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state224(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_22if_22_20_3cCond_3e_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state159(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 205
    //   Alternatives = "{" Alternative* "}" ";" (*) [EOF]
    //   Alternatives = "{" Alternative* "}" ";" (*) ["Escape"]
    //   Alternatives = "{" Alternative* "}" ";" (*) ["Id"]
    //   Alternatives = "{" Alternative* "}" ";" (*) ["MacroId"]
    //   Alternatives = "{" Alternative* "}" ";" (*) ["extern"]
    //   Alternatives = "{" Alternative* "}" ";" (*) ["pub"]
    //   Alternatives = "{" Alternative* "}" ";" (*) ["use"]
    //
    //   "pub" -> Reduce(Alternatives = "{", Alternative*, "}", ";" => Call(ActionFn(17));)
    //   "use" -> Reduce(Alternatives = "{", Alternative*, "}", ";" => Call(ActionFn(17));)
    //   "Id" -> Reduce(Alternatives = "{", Alternative*, "}", ";" => Call(ActionFn(17));)
    //   EOF -> Reduce(Alternatives = "{", Alternative*, "}", ";" => Call(ActionFn(17));)
    //   "Escape" -> Reduce(Alternatives = "{", Alternative*, "}", ";" => Call(ActionFn(17));)
    //   "extern" -> Reduce(Alternatives = "{", Alternative*, "}", ";" => Call(ActionFn(17));)
    //   "MacroId" -> Reduce(Alternatives = "{", Alternative*, "}", ";" => Call(ActionFn(17));)
    //
    pub fn __state205<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::vec::Vec<Alternative>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action17(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action17(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action17(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action17(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action17(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action17(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action17(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternatives(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 206
    //   (<TypeRefOrLifetime> ",")* = (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (*) (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? [">"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" ["{"]
    //
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //
    //   Comma<TypeRefOrLifetime> -> S225
    //   (<TypeRefOrLifetime> ",")* -> S81
    pub fn __state206<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state225(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state81(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 207
    //   TypeRef = "(" Comma<TypeRef> (*) ")" ["{"]
    //
    //   ")" -> Shift(S226)
    //
    pub fn __state207<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state226(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 208
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["<"]
    //   Id = (*) "Id" ["{"]
    //   Path = "::"? (<Id> "::")* (*) Id ["<"]
    //   Path = "::"? (<Id> "::")* (*) Id ["{"]
    //
    //   "Id" -> Shift(S228)
    //
    //   Id -> S227
    //   (<Id> "::") -> S80
    pub fn __state208<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state228(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state227(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state80(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 209
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R (*) "{" Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R (*) "{" Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R (*) "{" Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R (*) "{" Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R (*) "{" Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R (*) "{" Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R (*) "{" Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "{" -> Shift(S229)
    //
    pub fn __state209<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
        __sym8: &mut Option<TypeRef>,
        __sym9: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym10 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state229(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 210
    //   "mut"? = (*) ["&"]
    //   "mut"? = (*) ["("]
    //   "mut"? = (*) ["::"]
    //   "mut"? = (*) ["Escape"]
    //   "mut"? = (*) ["Id"]
    //   "mut"? = (*) "mut" ["&"]
    //   "mut"? = (*) "mut" ["("]
    //   "mut"? = (*) "mut" ["::"]
    //   "mut"? = (*) "mut" ["Escape"]
    //   "mut"? = (*) "mut" ["Id"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef ["{"]
    //
    //   "&" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "(" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "Id" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "mut" -> Shift(S73)
    //   "Escape" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "::" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //
    //   "mut"? -> S230
    pub fn __state210<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Mut(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state73(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22mut_22_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state230(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 211
    //   AssociatedType = "type" @L Id @R (*) "=" TypeRef ";" ["enum"]
    //   AssociatedType = "type" @L Id @R (*) "=" TypeRef ";" ["type"]
    //
    //   "=" -> Shift(S231)
    //
    pub fn __state211<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
        __sym3: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Equals(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state231(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 212
    //   Cond = @L NonterminalId (*) CondOp StringLiteral @R [";"]
    //   Cond = @L NonterminalId (*) CondOp StringLiteral @R ["=>"]
    //   Cond = @L NonterminalId (*) CondOp StringLiteral @R ["=>?"]
    //   Cond = @L NonterminalId (*) CondOp StringLiteral @R ["=>@L"]
    //   Cond = @L NonterminalId (*) CondOp StringLiteral @R ["=>@R"]
    //   CondOp = (*) "!=" ["StringLiteral"]
    //   CondOp = (*) "!~" ["StringLiteral"]
    //   CondOp = (*) "==" ["StringLiteral"]
    //   CondOp = (*) "~~" ["StringLiteral"]
    //
    //   "!=" -> Shift(S236)
    //   "==" -> Shift(S233)
    //   "!~" -> Shift(S232)
    //   "~~" -> Shift(S234)
    //
    //   CondOp -> S235
    pub fn __state212<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::BangEquals(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state236(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, __tok @ Tok::EqualsEquals(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state233(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, __tok @ Tok::BangTilde(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state232(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, __tok @ Tok::TildeTilde(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state234(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::CondOp(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state235(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 213
    //   Id = "Id" (*) ["!="]
    //   Id = "Id" (*) ["!~"]
    //   Id = "Id" (*) ["=="]
    //   Id = "Id" (*) ["~~"]
    //
    //   "!=" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "~~" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "==" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "!~" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state213<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::BangEquals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::TildeTilde(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::EqualsEquals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::BangTilde(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 214
    //   NonterminalId = Id (*) ["!="]
    //   NonterminalId = Id (*) ["!~"]
    //   NonterminalId = Id (*) ["=="]
    //   NonterminalId = Id (*) ["~~"]
    //
    //   "~~" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "!=" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "==" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "!~" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //
    pub fn __state214<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::TildeTilde(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::BangEquals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::EqualsEquals(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::BangTilde(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 215
    //   @R = (*) [EOF]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["extern"]
    //   @R = (*) ["pub"]
    //   @R = (*) ["use"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R [EOF]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["Escape"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["Id"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["MacroId"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["extern"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["pub"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["use"]
    //
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //   "use" -> Reduce(@R =  => Lookbehind;)
    //   "extern" -> Reduce(@R =  => Lookbehind;)
    //   "pub" -> Reduce(@R =  => Lookbehind;)
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //   EOF -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S237
    pub fn __state215<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<::std::option::Option<Condition>>,
        __sym3: &mut Option<::std::option::Option<ActionKind>>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Use(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            None => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym4.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state237(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 216
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["("]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["*"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["+"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) [";"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["<"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["=>"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["=>?"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["=>@L"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["=>@R"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["?"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["@L"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["@R"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["Escape"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["Id"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["MacroId"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["StringLiteral"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["if"]
    //
    //   "=>@L" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "StringLiteral" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "=>?" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "(" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "=>" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "Escape" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "if" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "?" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "<" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "@L" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "Id" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "=>@R" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "@R" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "+" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "MacroId" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   ";" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "*" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //
    pub fn __state216<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
        __sym1: &mut Option<RepeatOp>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 217
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["("]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["*"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["+"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" [";"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["<"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["=>"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["=>?"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["=>@L"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["=>@R"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["?"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["@L"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["@R"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["Escape"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["Id"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["MacroId"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["StringLiteral"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["if"]
    //
    //   ")" -> Shift(S238)
    //
    pub fn __state217<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<ExprSymbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state238(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 218
    //   @L = (*) ["("]
    //   @L = (*) ["<"]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   ExprSymbol = Symbol* (*) [")"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["("]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R [")"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["<"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["@L"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["@R"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["Id"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["("]
    //   Symbol = (*) @L "<" Symbol0 ">" @R [")"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["<"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["@L"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["@R"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["Escape"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["Id"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["MacroId"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = (*) Symbol0 ["("]
    //   Symbol = (*) Symbol0 [")"]
    //   Symbol = (*) Symbol0 ["<"]
    //   Symbol = (*) Symbol0 ["@L"]
    //   Symbol = (*) Symbol0 ["@R"]
    //   Symbol = (*) Symbol0 ["Escape"]
    //   Symbol = (*) Symbol0 ["Id"]
    //   Symbol = (*) Symbol0 ["MacroId"]
    //   Symbol = (*) Symbol0 ["StringLiteral"]
    //   Symbol* = Symbol* (*) Symbol ["("]
    //   Symbol* = Symbol* (*) Symbol [")"]
    //   Symbol* = Symbol* (*) Symbol ["<"]
    //   Symbol* = Symbol* (*) Symbol ["@L"]
    //   Symbol* = Symbol* (*) Symbol ["@R"]
    //   Symbol* = Symbol* (*) Symbol ["Escape"]
    //   Symbol* = Symbol* (*) Symbol ["Id"]
    //   Symbol* = Symbol* (*) Symbol ["MacroId"]
    //   Symbol* = Symbol* (*) Symbol ["StringLiteral"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["("]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [")"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["*"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["+"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["<"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["?"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["@L"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["@R"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["Escape"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["Id"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["MacroId"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["StringLiteral"]
    //   Symbol0 = (*) Symbol1 ["("]
    //   Symbol0 = (*) Symbol1 [")"]
    //   Symbol0 = (*) Symbol1 ["*"]
    //   Symbol0 = (*) Symbol1 ["+"]
    //   Symbol0 = (*) Symbol1 ["<"]
    //   Symbol0 = (*) Symbol1 ["?"]
    //   Symbol0 = (*) Symbol1 ["@L"]
    //   Symbol0 = (*) Symbol1 ["@R"]
    //   Symbol0 = (*) Symbol1 ["Escape"]
    //   Symbol0 = (*) Symbol1 ["Id"]
    //   Symbol0 = (*) Symbol1 ["MacroId"]
    //   Symbol0 = (*) Symbol1 ["StringLiteral"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["("]
    //   Symbol1 = (*) @L SymbolKind1 @R [")"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["*"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["+"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["<"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["@L"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["@R"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["Escape"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["Id"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["MacroId"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["StringLiteral"]
    //
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   ")" -> Reduce(ExprSymbol = Symbol* => Call(ActionFn(28));)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "<" -> Reduce(@L =  => Lookahead;)
    //
    //   Symbol1 -> S240
    //   Symbol -> S241
    //   Symbol0 -> S239
    //   @L -> S242
    pub fn __state218<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Symbol>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action28(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExprSymbol(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol1(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state240(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Symbol(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state241(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Symbol0(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state239(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state242(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 219
    //   Symbol1 = @L SymbolKind1 @R (*) ["("]
    //   Symbol1 = @L SymbolKind1 @R (*) ["*"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["+"]
    //   Symbol1 = @L SymbolKind1 @R (*) [";"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["<"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["=>"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["=>?"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["=>@L"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["=>@R"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["?"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["@L"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["@R"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["Escape"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["Id"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["MacroId"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["StringLiteral"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["if"]
    //
    //   "=>" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "MacroId" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "=>@R" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "=>@L" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "@R" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "*" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "<" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "Id" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "(" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "Escape" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "?" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "=>?" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   ";" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "StringLiteral" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "if" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "+" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "@L" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //
    pub fn __state219<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<SymbolKind>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 220
    //   Symbol0 = Symbol1 (*) ["*"]
    //   Symbol0 = Symbol1 (*) ["+"]
    //   Symbol0 = Symbol1 (*) [">"]
    //   Symbol0 = Symbol1 (*) ["?"]
    //
    //   "+" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "?" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "*" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   ">" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //
    pub fn __state220<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 221
    //   Escape = (*) "Escape" ["*"]
    //   Escape = (*) "Escape" ["+"]
    //   Escape = (*) "Escape" [">"]
    //   Escape = (*) "Escape" ["?"]
    //   Id = (*) "Id" ["*"]
    //   Id = (*) "Id" ["+"]
    //   Id = (*) "Id" [":"]
    //   Id = (*) "Id" [">"]
    //   Id = (*) "Id" ["?"]
    //   MacroId = (*) "MacroId" ["<"]
    //   NonterminalId = (*) Id ["*"]
    //   NonterminalId = (*) Id ["+"]
    //   NonterminalId = (*) Id [">"]
    //   NonterminalId = (*) Id ["?"]
    //   StringLiteral = (*) "StringLiteral" ["*"]
    //   StringLiteral = (*) "StringLiteral" ["+"]
    //   StringLiteral = (*) "StringLiteral" [">"]
    //   StringLiteral = (*) "StringLiteral" ["?"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["("]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R [";"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["=>"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["=>?"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["=>@L"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["=>@R"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["if"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["*"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["+"]
    //   Symbol1 = @L (*) SymbolKind1 @R [">"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["?"]
    //   SymbolKind1 = (*) Escape ["*"]
    //   SymbolKind1 = (*) Escape ["+"]
    //   SymbolKind1 = (*) Escape [">"]
    //   SymbolKind1 = (*) Escape ["?"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" [">"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = (*) NonterminalId ["*"]
    //   SymbolKind1 = (*) NonterminalId ["+"]
    //   SymbolKind1 = (*) NonterminalId [">"]
    //   SymbolKind1 = (*) NonterminalId ["?"]
    //   SymbolKind1 = (*) Terminal ["*"]
    //   SymbolKind1 = (*) Terminal ["+"]
    //   SymbolKind1 = (*) Terminal [">"]
    //   SymbolKind1 = (*) Terminal ["?"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["*"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["+"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" [">"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["?"]
    //   SymbolKind1 = (*) "@L" ["*"]
    //   SymbolKind1 = (*) "@L" ["+"]
    //   SymbolKind1 = (*) "@L" [">"]
    //   SymbolKind1 = (*) "@L" ["?"]
    //   SymbolKind1 = (*) "@R" ["*"]
    //   SymbolKind1 = (*) "@R" ["+"]
    //   SymbolKind1 = (*) "@R" [">"]
    //   SymbolKind1 = (*) "@R" ["?"]
    //   Terminal = (*) StringLiteral ["*"]
    //   Terminal = (*) StringLiteral ["+"]
    //   Terminal = (*) StringLiteral [">"]
    //   Terminal = (*) StringLiteral ["?"]
    //
    //   "Id" -> Shift(S249)
    //   "Escape" -> Shift(S250)
    //   "@R" -> Shift(S255)
    //   "@L" -> Shift(S246)
    //   "(" -> Shift(S248)
    //   "StringLiteral" -> Shift(S244)
    //   "MacroId" -> Shift(S68)
    //
    //   Terminal -> S243
    //   Id -> S247
    //   Escape -> S252
    //   MacroId -> S245
    //   SymbolKind1 -> S251
    //   StringLiteral -> S253
    //   NonterminalId -> S254
    pub fn __state221<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state249(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state250(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Lookbehind(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state255(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Lookahead(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state246(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state248(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::StringLiteral(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state244(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::MacroId(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Terminal(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state243(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state247(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state252(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::MacroId(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state245(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::SymbolKind1(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state251(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
                }
                __Nonterminal::StringLiteral(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state253(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state254(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 222
    //   RepeatOp = (*) "*" ["*"]
    //   RepeatOp = (*) "*" ["+"]
    //   RepeatOp = (*) "*" [">"]
    //   RepeatOp = (*) "*" ["?"]
    //   RepeatOp = (*) "+" ["*"]
    //   RepeatOp = (*) "+" ["+"]
    //   RepeatOp = (*) "+" [">"]
    //   RepeatOp = (*) "+" ["?"]
    //   RepeatOp = (*) "?" ["*"]
    //   RepeatOp = (*) "?" ["+"]
    //   RepeatOp = (*) "?" [">"]
    //   RepeatOp = (*) "?" ["?"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["("]
    //   Symbol = @L "<" Symbol0 (*) ">" @R [";"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["<"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["=>"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["=>?"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["=>@L"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["=>@R"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["@L"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["@R"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["Escape"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["Id"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["MacroId"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["StringLiteral"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["if"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["*"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["+"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["?"]
    //
    //   ">" -> Shift(S258)
    //   "*" -> Shift(S257)
    //   "?" -> Shift(S259)
    //   "+" -> Shift(S260)
    //
    //   RepeatOp -> S256
    pub fn __state222<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state258(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            Some((_, __tok @ Tok::Star(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state257(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Question(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state259(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Plus(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state260(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::RepeatOp(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state256(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 223
    //   (<Symbol> ",")* = (*) ["("]
    //   (<Symbol> ",")* = (*) ["<"]
    //   (<Symbol> ",")* = (*) [">"]
    //   (<Symbol> ",")* = (*) ["@L"]
    //   (<Symbol> ",")* = (*) ["@R"]
    //   (<Symbol> ",")* = (*) ["Escape"]
    //   (<Symbol> ",")* = (*) ["Id"]
    //   (<Symbol> ",")* = (*) ["MacroId"]
    //   (<Symbol> ",")* = (*) ["StringLiteral"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["("]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["<"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") [">"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["@L"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["@R"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["Escape"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["Id"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["MacroId"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["StringLiteral"]
    //   Comma<Symbol> = (*) (<Symbol> ",")* Symbol? [">"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["("]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" [";"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["<"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["=>"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["=>?"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["=>@L"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["=>@R"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["@L"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["@R"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["Escape"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["Id"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["MacroId"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["StringLiteral"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["if"]
    //
    //   "MacroId" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   ">" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "@R" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "Escape" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "@L" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "(" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "<" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "StringLiteral" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "Id" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //
    //   Comma<Symbol> -> S262
    //   (<Symbol> ",")* -> S261
    pub fn __state223<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cSymbol_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state262(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state261(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 224
    //   Action = (*) "=>" [";"]
    //   Action = (*) "=>?" [";"]
    //   Action = (*) "=>@L" [";"]
    //   Action = (*) "=>@R" [";"]
    //   Action? = (*) [";"]
    //   Action? = (*) Action [";"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["("]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R [";"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["<"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["=>"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["=>?"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["=>@L"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["=>@R"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["@L"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["@R"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["Escape"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["Id"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["MacroId"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["StringLiteral"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["if"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? (*) Action? ";" @R ["}"]
    //
    //   "=>?" -> Shift(S183)
    //   "=>@R" -> Shift(S180)
    //   ";" -> Reduce(Action? =  => Call(ActionFn(97));)
    //   "=>" -> Shift(S184)
    //   "=>@L" -> Shift(S185)
    //
    //   Action? -> S263
    //   Action -> S182
    pub fn __state224<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<::std::option::Option<Condition>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanQuestionCode(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state183(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::EqualsGreaterThanLookbehind(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state180(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::EqualsGreaterThanCode(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state184(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::EqualsGreaterThanLookahead(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state185(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = super::__action97(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Action_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Action_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state263(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::Action(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state182(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 225
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" ["{"]
    //
    //   ">" -> Shift(S264)
    //
    pub fn __state225<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state264(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 226
    //   TypeRef = "(" Comma<TypeRef> ")" (*) ["{"]
    //
    //   "{" -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //
    pub fn __state226<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 227
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) ["<"]
    //   Path = "::"? (<Id> "::")* Id (*) ["{"]
    //
    //   "<" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "{" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S88)
    //
    pub fn __state227<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state88(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 228
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["<"]
    //   Id = "Id" (*) ["{"]
    //
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "{" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state228<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 229
    //   (<Conversion> ",")* = (*) ["StringLiteral"]
    //   (<Conversion> ",")* = (*) ["}"]
    //   (<Conversion> ",")* = (*) (<Conversion> ",")* (<Conversion> ",") ["StringLiteral"]
    //   (<Conversion> ",")* = (*) (<Conversion> ",")* (<Conversion> ",") ["}"]
    //   Comma<Conversion> = (*) (<Conversion> ",")* Conversion? ["}"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" (*) Comma<Conversion> "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" (*) Comma<Conversion> "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" (*) Comma<Conversion> "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" (*) Comma<Conversion> "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" (*) Comma<Conversion> "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" (*) Comma<Conversion> "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" (*) Comma<Conversion> "}" AssociatedType* "}" ["use"]
    //
    //   "StringLiteral" -> Reduce((<Conversion> ",")* =  => Call(ActionFn(153));)
    //   "}" -> Reduce((<Conversion> ",")* =  => Call(ActionFn(153));)
    //
    //   (<Conversion> ",")* -> S265
    //   Comma<Conversion> -> S266
    pub fn __state229<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
        __sym8: &mut Option<TypeRef>,
        __sym9: &mut Option<usize>,
        __sym10: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action153(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cConversion_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action153(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cConversion_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym10.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cConversion_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym11 = &mut Some(__nt);
                    __result = try!(__state265(text, __lookbehind, __lookahead, __tokens, __sym11));
                }
                __Nonterminal::Comma_3cConversion_3e(__nt) => {
                    let __sym11 = &mut Some(__nt);
                    __result = try!(__state266(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 230
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" ["{"]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id ["{"]
    //   TypeRef = (*) Escape ["{"]
    //   TypeRef = (*) Path ["{"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" ["{"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef ["{"]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef ["{"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" ["{"]
    //
    //   "&" -> Shift(S175)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "Escape" -> Shift(S170)
    //   "(" -> Shift(S171)
    //   "::" -> Shift(S50)
    //
    //   Escape -> S173
    //   TypeRef -> S267
    //   Path -> S169
    //   "::"? -> S172
    pub fn __state230<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state175(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state170(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state171(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state173(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state267(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state169(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state172(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 231
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   AssociatedType = "type" @L Id @R "=" (*) TypeRef ";" ["enum"]
    //   AssociatedType = "type" @L Id @R "=" (*) TypeRef ";" ["type"]
    //   Escape = (*) "Escape" [";"]
    //   Path = (*) "::"? (<Id> "::")* Id [";"]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   TypeRef = (*) Escape [";"]
    //   TypeRef = (*) Path [";"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [";"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [";"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [";"]
    //
    //   "Escape" -> Shift(S268)
    //   "::" -> Shift(S50)
    //   "&" -> Shift(S273)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "(" -> Shift(S270)
    //
    //   "::"? -> S272
    //   TypeRef -> S269
    //   Escape -> S271
    //   Path -> S274
    pub fn __state231<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state268(text, __lookbehind, __lookahead, __tokens, __sym5));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym5));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state273(text, __lookbehind, __lookahead, __tokens, __sym5));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state270(text, __lookbehind, __lookahead, __tokens, __sym5));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym4.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state272(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state269(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state271(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state274(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 232
    //   CondOp = "!~" (*) ["StringLiteral"]
    //
    //   "StringLiteral" -> Reduce(CondOp = "!~" => Call(ActionFn(27));)
    //
    pub fn __state232<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action27(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::CondOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 233
    //   CondOp = "==" (*) ["StringLiteral"]
    //
    //   "StringLiteral" -> Reduce(CondOp = "==" => Call(ActionFn(24));)
    //
    pub fn __state233<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action24(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::CondOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 234
    //   CondOp = "~~" (*) ["StringLiteral"]
    //
    //   "StringLiteral" -> Reduce(CondOp = "~~" => Call(ActionFn(26));)
    //
    pub fn __state234<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action26(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::CondOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 235
    //   Cond = @L NonterminalId CondOp (*) StringLiteral @R [";"]
    //   Cond = @L NonterminalId CondOp (*) StringLiteral @R ["=>"]
    //   Cond = @L NonterminalId CondOp (*) StringLiteral @R ["=>?"]
    //   Cond = @L NonterminalId CondOp (*) StringLiteral @R ["=>@L"]
    //   Cond = @L NonterminalId CondOp (*) StringLiteral @R ["=>@R"]
    //   StringLiteral = (*) "StringLiteral" [";"]
    //   StringLiteral = (*) "StringLiteral" ["=>"]
    //   StringLiteral = (*) "StringLiteral" ["=>?"]
    //   StringLiteral = (*) "StringLiteral" ["=>@L"]
    //   StringLiteral = (*) "StringLiteral" ["=>@R"]
    //
    //   "StringLiteral" -> Shift(S275)
    //
    //   StringLiteral -> S276
    pub fn __state235<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<NonterminalString>,
        __sym2: &mut Option<ConditionOp>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state275(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::StringLiteral(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state276(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 236
    //   CondOp = "!=" (*) ["StringLiteral"]
    //
    //   "StringLiteral" -> Reduce(CondOp = "!=" => Call(ActionFn(25));)
    //
    pub fn __state236<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action25(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::CondOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 237
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) [EOF]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["Escape"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["Id"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["MacroId"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["extern"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["pub"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["use"]
    //
    //   "use" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "extern" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "pub" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "Id" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   EOF -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "Escape" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "MacroId" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //
    pub fn __state237<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<::std::option::Option<Condition>>,
        __sym3: &mut Option<::std::option::Option<ActionKind>>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 238
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["("]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["*"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["+"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) [";"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["<"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["=>"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["=>?"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["=>@L"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["=>@R"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["?"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["@L"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["@R"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["Escape"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["Id"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["MacroId"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["StringLiteral"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["if"]
    //
    //   "=>@L" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "?" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "=>@R" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "*" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "Escape" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "@R" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "(" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "+" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "=>" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "MacroId" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "Id" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "if" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   ";" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "<" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "@L" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "=>?" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //
    pub fn __state238<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 239
    //   RepeatOp = (*) "*" ["("]
    //   RepeatOp = (*) "*" [")"]
    //   RepeatOp = (*) "*" ["*"]
    //   RepeatOp = (*) "*" ["+"]
    //   RepeatOp = (*) "*" ["<"]
    //   RepeatOp = (*) "*" ["?"]
    //   RepeatOp = (*) "*" ["@L"]
    //   RepeatOp = (*) "*" ["@R"]
    //   RepeatOp = (*) "*" ["Escape"]
    //   RepeatOp = (*) "*" ["Id"]
    //   RepeatOp = (*) "*" ["MacroId"]
    //   RepeatOp = (*) "*" ["StringLiteral"]
    //   RepeatOp = (*) "+" ["("]
    //   RepeatOp = (*) "+" [")"]
    //   RepeatOp = (*) "+" ["*"]
    //   RepeatOp = (*) "+" ["+"]
    //   RepeatOp = (*) "+" ["<"]
    //   RepeatOp = (*) "+" ["?"]
    //   RepeatOp = (*) "+" ["@L"]
    //   RepeatOp = (*) "+" ["@R"]
    //   RepeatOp = (*) "+" ["Escape"]
    //   RepeatOp = (*) "+" ["Id"]
    //   RepeatOp = (*) "+" ["MacroId"]
    //   RepeatOp = (*) "+" ["StringLiteral"]
    //   RepeatOp = (*) "?" ["("]
    //   RepeatOp = (*) "?" [")"]
    //   RepeatOp = (*) "?" ["*"]
    //   RepeatOp = (*) "?" ["+"]
    //   RepeatOp = (*) "?" ["<"]
    //   RepeatOp = (*) "?" ["?"]
    //   RepeatOp = (*) "?" ["@L"]
    //   RepeatOp = (*) "?" ["@R"]
    //   RepeatOp = (*) "?" ["Escape"]
    //   RepeatOp = (*) "?" ["Id"]
    //   RepeatOp = (*) "?" ["MacroId"]
    //   RepeatOp = (*) "?" ["StringLiteral"]
    //   Symbol = Symbol0 (*) ["("]
    //   Symbol = Symbol0 (*) [")"]
    //   Symbol = Symbol0 (*) ["<"]
    //   Symbol = Symbol0 (*) ["@L"]
    //   Symbol = Symbol0 (*) ["@R"]
    //   Symbol = Symbol0 (*) ["Escape"]
    //   Symbol = Symbol0 (*) ["Id"]
    //   Symbol = Symbol0 (*) ["MacroId"]
    //   Symbol = Symbol0 (*) ["StringLiteral"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["("]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [")"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["*"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["+"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["<"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["?"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["@L"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["@R"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["Escape"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["Id"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["MacroId"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["StringLiteral"]
    //
    //   "Escape" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "@L" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "Id" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "MacroId" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "+" -> Shift(S278)
    //   ")" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "<" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "StringLiteral" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "(" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   "?" -> Shift(S280)
    //   "*" -> Shift(S279)
    //   "@R" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //
    //   RepeatOp -> S277
    pub fn __state239<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Plus(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state278(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Question(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state280(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Star(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state279(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::RepeatOp(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state277(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 240
    //   Symbol0 = Symbol1 (*) ["("]
    //   Symbol0 = Symbol1 (*) [")"]
    //   Symbol0 = Symbol1 (*) ["*"]
    //   Symbol0 = Symbol1 (*) ["+"]
    //   Symbol0 = Symbol1 (*) ["<"]
    //   Symbol0 = Symbol1 (*) ["?"]
    //   Symbol0 = Symbol1 (*) ["@L"]
    //   Symbol0 = Symbol1 (*) ["@R"]
    //   Symbol0 = Symbol1 (*) ["Escape"]
    //   Symbol0 = Symbol1 (*) ["Id"]
    //   Symbol0 = Symbol1 (*) ["MacroId"]
    //   Symbol0 = Symbol1 (*) ["StringLiteral"]
    //
    //   "(" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "?" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "Id" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "@R" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "*" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "@L" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   ")" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "<" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "MacroId" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "Escape" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "+" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "StringLiteral" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //
    pub fn __state240<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 241
    //   Symbol* = Symbol* Symbol (*) ["("]
    //   Symbol* = Symbol* Symbol (*) [")"]
    //   Symbol* = Symbol* Symbol (*) ["<"]
    //   Symbol* = Symbol* Symbol (*) ["@L"]
    //   Symbol* = Symbol* Symbol (*) ["@R"]
    //   Symbol* = Symbol* Symbol (*) ["Escape"]
    //   Symbol* = Symbol* Symbol (*) ["Id"]
    //   Symbol* = Symbol* Symbol (*) ["MacroId"]
    //   Symbol* = Symbol* Symbol (*) ["StringLiteral"]
    //
    //   "@L" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "Id" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "@R" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "<" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "(" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "StringLiteral" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "Escape" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   ")" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //   "MacroId" -> Reduce(Symbol* = Symbol*, Symbol => Call(ActionFn(95));)
    //
    pub fn __state241<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Symbol>>,
        __sym1: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action95(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 242
    //   Escape = (*) "Escape" ["("]
    //   Escape = (*) "Escape" [")"]
    //   Escape = (*) "Escape" ["*"]
    //   Escape = (*) "Escape" ["+"]
    //   Escape = (*) "Escape" ["<"]
    //   Escape = (*) "Escape" ["?"]
    //   Escape = (*) "Escape" ["@L"]
    //   Escape = (*) "Escape" ["@R"]
    //   Escape = (*) "Escape" ["Escape"]
    //   Escape = (*) "Escape" ["Id"]
    //   Escape = (*) "Escape" ["MacroId"]
    //   Escape = (*) "Escape" ["StringLiteral"]
    //   Id = (*) "Id" ["("]
    //   Id = (*) "Id" [")"]
    //   Id = (*) "Id" ["*"]
    //   Id = (*) "Id" ["+"]
    //   Id = (*) "Id" ["<"]
    //   Id = (*) "Id" ["?"]
    //   Id = (*) "Id" ["@L"]
    //   Id = (*) "Id" ["@R"]
    //   Id = (*) "Id" ["Escape"]
    //   Id = (*) "Id" ["Id"]
    //   Id = (*) "Id" ["MacroId"]
    //   Id = (*) "Id" ["StringLiteral"]
    //   MacroId = (*) "MacroId" ["<"]
    //   NonterminalId = (*) Id ["("]
    //   NonterminalId = (*) Id [")"]
    //   NonterminalId = (*) Id ["*"]
    //   NonterminalId = (*) Id ["+"]
    //   NonterminalId = (*) Id ["<"]
    //   NonterminalId = (*) Id ["?"]
    //   NonterminalId = (*) Id ["@L"]
    //   NonterminalId = (*) Id ["@R"]
    //   NonterminalId = (*) Id ["Escape"]
    //   NonterminalId = (*) Id ["Id"]
    //   NonterminalId = (*) Id ["MacroId"]
    //   NonterminalId = (*) Id ["StringLiteral"]
    //   StringLiteral = (*) "StringLiteral" ["("]
    //   StringLiteral = (*) "StringLiteral" [")"]
    //   StringLiteral = (*) "StringLiteral" ["*"]
    //   StringLiteral = (*) "StringLiteral" ["+"]
    //   StringLiteral = (*) "StringLiteral" ["<"]
    //   StringLiteral = (*) "StringLiteral" ["?"]
    //   StringLiteral = (*) "StringLiteral" ["@L"]
    //   StringLiteral = (*) "StringLiteral" ["@R"]
    //   StringLiteral = (*) "StringLiteral" ["Escape"]
    //   StringLiteral = (*) "StringLiteral" ["Id"]
    //   StringLiteral = (*) "StringLiteral" ["MacroId"]
    //   StringLiteral = (*) "StringLiteral" ["StringLiteral"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["("]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R [")"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["<"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["@L"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["@R"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["Id"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["("]
    //   Symbol = @L (*) "<" Symbol0 ">" @R [")"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["<"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["@L"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["@R"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["Id"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["("]
    //   Symbol1 = @L (*) SymbolKind1 @R [")"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["*"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["+"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["<"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["?"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["@L"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["@R"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["Escape"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["Id"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["MacroId"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["StringLiteral"]
    //   SymbolKind1 = (*) Escape ["("]
    //   SymbolKind1 = (*) Escape [")"]
    //   SymbolKind1 = (*) Escape ["*"]
    //   SymbolKind1 = (*) Escape ["+"]
    //   SymbolKind1 = (*) Escape ["<"]
    //   SymbolKind1 = (*) Escape ["?"]
    //   SymbolKind1 = (*) Escape ["@L"]
    //   SymbolKind1 = (*) Escape ["@R"]
    //   SymbolKind1 = (*) Escape ["Escape"]
    //   SymbolKind1 = (*) Escape ["Id"]
    //   SymbolKind1 = (*) Escape ["MacroId"]
    //   SymbolKind1 = (*) Escape ["StringLiteral"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["("]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" [")"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["<"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["@L"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["@R"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["Escape"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["Id"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["MacroId"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["StringLiteral"]
    //   SymbolKind1 = (*) NonterminalId ["("]
    //   SymbolKind1 = (*) NonterminalId [")"]
    //   SymbolKind1 = (*) NonterminalId ["*"]
    //   SymbolKind1 = (*) NonterminalId ["+"]
    //   SymbolKind1 = (*) NonterminalId ["<"]
    //   SymbolKind1 = (*) NonterminalId ["?"]
    //   SymbolKind1 = (*) NonterminalId ["@L"]
    //   SymbolKind1 = (*) NonterminalId ["@R"]
    //   SymbolKind1 = (*) NonterminalId ["Escape"]
    //   SymbolKind1 = (*) NonterminalId ["Id"]
    //   SymbolKind1 = (*) NonterminalId ["MacroId"]
    //   SymbolKind1 = (*) NonterminalId ["StringLiteral"]
    //   SymbolKind1 = (*) Terminal ["("]
    //   SymbolKind1 = (*) Terminal [")"]
    //   SymbolKind1 = (*) Terminal ["*"]
    //   SymbolKind1 = (*) Terminal ["+"]
    //   SymbolKind1 = (*) Terminal ["<"]
    //   SymbolKind1 = (*) Terminal ["?"]
    //   SymbolKind1 = (*) Terminal ["@L"]
    //   SymbolKind1 = (*) Terminal ["@R"]
    //   SymbolKind1 = (*) Terminal ["Escape"]
    //   SymbolKind1 = (*) Terminal ["Id"]
    //   SymbolKind1 = (*) Terminal ["MacroId"]
    //   SymbolKind1 = (*) Terminal ["StringLiteral"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["("]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" [")"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["*"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["+"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["<"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["?"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["@L"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["@R"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["Escape"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["Id"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["MacroId"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["StringLiteral"]
    //   SymbolKind1 = (*) "@L" ["("]
    //   SymbolKind1 = (*) "@L" [")"]
    //   SymbolKind1 = (*) "@L" ["*"]
    //   SymbolKind1 = (*) "@L" ["+"]
    //   SymbolKind1 = (*) "@L" ["<"]
    //   SymbolKind1 = (*) "@L" ["?"]
    //   SymbolKind1 = (*) "@L" ["@L"]
    //   SymbolKind1 = (*) "@L" ["@R"]
    //   SymbolKind1 = (*) "@L" ["Escape"]
    //   SymbolKind1 = (*) "@L" ["Id"]
    //   SymbolKind1 = (*) "@L" ["MacroId"]
    //   SymbolKind1 = (*) "@L" ["StringLiteral"]
    //   SymbolKind1 = (*) "@R" ["("]
    //   SymbolKind1 = (*) "@R" [")"]
    //   SymbolKind1 = (*) "@R" ["*"]
    //   SymbolKind1 = (*) "@R" ["+"]
    //   SymbolKind1 = (*) "@R" ["<"]
    //   SymbolKind1 = (*) "@R" ["?"]
    //   SymbolKind1 = (*) "@R" ["@L"]
    //   SymbolKind1 = (*) "@R" ["@R"]
    //   SymbolKind1 = (*) "@R" ["Escape"]
    //   SymbolKind1 = (*) "@R" ["Id"]
    //   SymbolKind1 = (*) "@R" ["MacroId"]
    //   SymbolKind1 = (*) "@R" ["StringLiteral"]
    //   Terminal = (*) StringLiteral ["("]
    //   Terminal = (*) StringLiteral [")"]
    //   Terminal = (*) StringLiteral ["*"]
    //   Terminal = (*) StringLiteral ["+"]
    //   Terminal = (*) StringLiteral ["<"]
    //   Terminal = (*) StringLiteral ["?"]
    //   Terminal = (*) StringLiteral ["@L"]
    //   Terminal = (*) StringLiteral ["@R"]
    //   Terminal = (*) StringLiteral ["Escape"]
    //   Terminal = (*) StringLiteral ["Id"]
    //   Terminal = (*) StringLiteral ["MacroId"]
    //   Terminal = (*) StringLiteral ["StringLiteral"]
    //
    //   "<" -> Shift(S282)
    //   "(" -> Shift(S281)
    //   "StringLiteral" -> Shift(S286)
    //   "@L" -> Shift(S288)
    //   "@R" -> Shift(S283)
    //   "MacroId" -> Shift(S68)
    //   "Escape" -> Shift(S287)
    //   "Id" -> Shift(S292)
    //
    //   NonterminalId -> S289
    //   MacroId -> S293
    //   Escape -> S294
    //   StringLiteral -> S291
    //   Terminal -> S285
    //   SymbolKind1 -> S284
    //   Id -> S290
    pub fn __state242<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state282(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state281(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::StringLiteral(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state286(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Lookahead(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state288(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Lookbehind(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state283(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::MacroId(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state287(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state292(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state289(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::MacroId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state293(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state294(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::StringLiteral(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state291(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Terminal(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state285(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::SymbolKind1(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state284(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state290(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 243
    //   SymbolKind1 = Terminal (*) ["*"]
    //   SymbolKind1 = Terminal (*) ["+"]
    //   SymbolKind1 = Terminal (*) [">"]
    //   SymbolKind1 = Terminal (*) ["?"]
    //
    //   ">" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "*" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "+" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "?" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //
    pub fn __state243<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TerminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 244
    //   StringLiteral = "StringLiteral" (*) ["*"]
    //   StringLiteral = "StringLiteral" (*) ["+"]
    //   StringLiteral = "StringLiteral" (*) [">"]
    //   StringLiteral = "StringLiteral" (*) ["?"]
    //
    //   "?" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   ">" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "*" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "+" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //
    pub fn __state244<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 245
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" [">"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["?"]
    //
    //   "<" -> Shift(S295)
    //
    pub fn __state245<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state295(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 246
    //   SymbolKind1 = "@L" (*) ["*"]
    //   SymbolKind1 = "@L" (*) ["+"]
    //   SymbolKind1 = "@L" (*) [">"]
    //   SymbolKind1 = "@L" (*) ["?"]
    //
    //   "?" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "+" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   ">" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "*" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //
    pub fn __state246<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 247
    //   NonterminalId = Id (*) ["*"]
    //   NonterminalId = Id (*) ["+"]
    //   NonterminalId = Id (*) [">"]
    //   NonterminalId = Id (*) ["?"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["("]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R [";"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["=>"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["=>?"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["=>@L"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["=>@R"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["if"]
    //
    //   "*" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   ">" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   ":" -> Shift(S296)
    //   "+" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "?" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //
    pub fn __state247<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Colon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state296(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 248
    //   ExprSymbol = (*) Symbol* [")"]
    //   Symbol* = (*) ["("]
    //   Symbol* = (*) [")"]
    //   Symbol* = (*) ["<"]
    //   Symbol* = (*) ["@L"]
    //   Symbol* = (*) ["@R"]
    //   Symbol* = (*) ["Escape"]
    //   Symbol* = (*) ["Id"]
    //   Symbol* = (*) ["MacroId"]
    //   Symbol* = (*) ["StringLiteral"]
    //   Symbol* = (*) Symbol* Symbol ["("]
    //   Symbol* = (*) Symbol* Symbol [")"]
    //   Symbol* = (*) Symbol* Symbol ["<"]
    //   Symbol* = (*) Symbol* Symbol ["@L"]
    //   Symbol* = (*) Symbol* Symbol ["@R"]
    //   Symbol* = (*) Symbol* Symbol ["Escape"]
    //   Symbol* = (*) Symbol* Symbol ["Id"]
    //   Symbol* = (*) Symbol* Symbol ["MacroId"]
    //   Symbol* = (*) Symbol* Symbol ["StringLiteral"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["*"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["+"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" [">"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["?"]
    //
    //   "@R" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@L" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Id" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "MacroId" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Escape" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "(" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "StringLiteral" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "<" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   ")" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //
    //   Symbol* -> S218
    //   ExprSymbol -> S297
    pub fn __state248<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state218(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::ExprSymbol(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state297(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 249
    //   Id = "Id" (*) ["*"]
    //   Id = "Id" (*) ["+"]
    //   Id = "Id" (*) [":"]
    //   Id = "Id" (*) [">"]
    //   Id = "Id" (*) ["?"]
    //
    //   "*" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "+" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   ":" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "?" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   ">" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state249<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Colon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 250
    //   Escape = "Escape" (*) ["*"]
    //   Escape = "Escape" (*) ["+"]
    //   Escape = "Escape" (*) [">"]
    //   Escape = "Escape" (*) ["?"]
    //
    //   "+" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "*" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "?" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   ">" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state250<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 251
    //   @R = (*) ["*"]
    //   @R = (*) ["+"]
    //   @R = (*) [">"]
    //   @R = (*) ["?"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["*"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["+"]
    //   Symbol1 = @L SymbolKind1 (*) @R [">"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["?"]
    //
    //   ">" -> Reduce(@R =  => Lookbehind;)
    //   "+" -> Reduce(@R =  => Lookbehind;)
    //   "?" -> Reduce(@R =  => Lookbehind;)
    //   "*" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S298
    pub fn __state251<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<SymbolKind>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Question(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Star(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state298(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 252
    //   SymbolKind1 = Escape (*) ["*"]
    //   SymbolKind1 = Escape (*) ["+"]
    //   SymbolKind1 = Escape (*) [">"]
    //   SymbolKind1 = Escape (*) ["?"]
    //
    //   ">" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "*" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "?" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "+" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //
    pub fn __state252<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 253
    //   Terminal = StringLiteral (*) ["*"]
    //   Terminal = StringLiteral (*) ["+"]
    //   Terminal = StringLiteral (*) [">"]
    //   Terminal = StringLiteral (*) ["?"]
    //
    //   "+" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "*" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "?" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   ">" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //
    pub fn __state253<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 254
    //   SymbolKind1 = NonterminalId (*) ["*"]
    //   SymbolKind1 = NonterminalId (*) ["+"]
    //   SymbolKind1 = NonterminalId (*) [">"]
    //   SymbolKind1 = NonterminalId (*) ["?"]
    //
    //   "*" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "?" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   ">" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "+" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //
    pub fn __state254<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 255
    //   SymbolKind1 = "@R" (*) ["*"]
    //   SymbolKind1 = "@R" (*) ["+"]
    //   SymbolKind1 = "@R" (*) [">"]
    //   SymbolKind1 = "@R" (*) ["?"]
    //
    //   "+" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "?" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   ">" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "*" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //
    pub fn __state255<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 256
    //   @R = (*) ["*"]
    //   @R = (*) ["+"]
    //   @R = (*) [">"]
    //   @R = (*) ["?"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["*"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["+"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R [">"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["?"]
    //
    //   "*" -> Reduce(@R =  => Lookbehind;)
    //   "+" -> Reduce(@R =  => Lookbehind;)
    //   "?" -> Reduce(@R =  => Lookbehind;)
    //   ">" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S299
    pub fn __state256<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
        __sym1: &mut Option<RepeatOp>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Question(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state299(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 257
    //   RepeatOp = "*" (*) ["*"]
    //   RepeatOp = "*" (*) ["+"]
    //   RepeatOp = "*" (*) [">"]
    //   RepeatOp = "*" (*) ["?"]
    //
    //   "*" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "+" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   ">" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "?" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //
    pub fn __state257<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 258
    //   @R = (*) ["("]
    //   @R = (*) [";"]
    //   @R = (*) ["<"]
    //   @R = (*) ["=>"]
    //   @R = (*) ["=>?"]
    //   @R = (*) ["=>@L"]
    //   @R = (*) ["=>@R"]
    //   @R = (*) ["@L"]
    //   @R = (*) ["@R"]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["StringLiteral"]
    //   @R = (*) ["if"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["("]
    //   Symbol = @L "<" Symbol0 ">" (*) @R [";"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["<"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["=>"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["=>?"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["=>@L"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["=>@R"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["@L"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["@R"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["Escape"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["Id"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["MacroId"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["StringLiteral"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["if"]
    //
    //   "if" -> Reduce(@R =  => Lookbehind;)
    //   "=>" -> Reduce(@R =  => Lookbehind;)
    //   "=>?" -> Reduce(@R =  => Lookbehind;)
    //   "=>@L" -> Reduce(@R =  => Lookbehind;)
    //   "@L" -> Reduce(@R =  => Lookbehind;)
    //   "StringLiteral" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   ";" -> Reduce(@R =  => Lookbehind;)
    //   "=>@R" -> Reduce(@R =  => Lookbehind;)
    //   "@R" -> Reduce(@R =  => Lookbehind;)
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S300
    pub fn __state258<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Symbol>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::If(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym3.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state300(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 259
    //   RepeatOp = "?" (*) ["*"]
    //   RepeatOp = "?" (*) ["+"]
    //   RepeatOp = "?" (*) [">"]
    //   RepeatOp = "?" (*) ["?"]
    //
    //   "?" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "*" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "+" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   ">" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //
    pub fn __state259<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 260
    //   RepeatOp = "+" (*) ["*"]
    //   RepeatOp = "+" (*) ["+"]
    //   RepeatOp = "+" (*) [">"]
    //   RepeatOp = "+" (*) ["?"]
    //
    //   "+" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "?" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   ">" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "*" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //
    pub fn __state260<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 261
    //   (<Symbol> ",") = (*) Symbol "," ["("]
    //   (<Symbol> ",") = (*) Symbol "," ["<"]
    //   (<Symbol> ",") = (*) Symbol "," [">"]
    //   (<Symbol> ",") = (*) Symbol "," ["@L"]
    //   (<Symbol> ",") = (*) Symbol "," ["@R"]
    //   (<Symbol> ",") = (*) Symbol "," ["Escape"]
    //   (<Symbol> ",") = (*) Symbol "," ["Id"]
    //   (<Symbol> ",") = (*) Symbol "," ["MacroId"]
    //   (<Symbol> ",") = (*) Symbol "," ["StringLiteral"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (*) (<Symbol> ",") ["("]
    //   (<Symbol> ",")* = (<Symbol> ",")* (*) (<Symbol> ",") ["<"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (*) (<Symbol> ",") [">"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (*) (<Symbol> ",") ["@L"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (*) (<Symbol> ",") ["@R"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (*) (<Symbol> ",") ["Escape"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (*) (<Symbol> ",") ["Id"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (*) (<Symbol> ",") ["MacroId"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (*) (<Symbol> ",") ["StringLiteral"]
    //   @L = (*) ["("]
    //   @L = (*) ["<"]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   Comma<Symbol> = (<Symbol> ",")* (*) Symbol? [">"]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R [","]
    //   Symbol = (*) @L "<" @L Id ":" Symbol0 ">" @R [">"]
    //   Symbol = (*) @L "<" Symbol0 ">" @R [","]
    //   Symbol = (*) @L "<" Symbol0 ">" @R [">"]
    //   Symbol = (*) Symbol0 [","]
    //   Symbol = (*) Symbol0 [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["*"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["+"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [","]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["?"]
    //   Symbol0 = (*) Symbol1 ["*"]
    //   Symbol0 = (*) Symbol1 ["+"]
    //   Symbol0 = (*) Symbol1 [","]
    //   Symbol0 = (*) Symbol1 [">"]
    //   Symbol0 = (*) Symbol1 ["?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["*"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["+"]
    //   Symbol1 = (*) @L SymbolKind1 @R [","]
    //   Symbol1 = (*) @L SymbolKind1 @R [">"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["?"]
    //   Symbol? = (*) [">"]
    //   Symbol? = (*) Symbol [">"]
    //
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   ">" -> Reduce(Symbol? =  => Call(ActionFn(137));)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "<" -> Reduce(@L =  => Lookahead;)
    //
    //   Symbol? -> S304
    //   Symbol0 -> S302
    //   (<Symbol> ",") -> S303
    //   Symbol -> S301
    //   Symbol1 -> S306
    //   @L -> S305
    pub fn __state261<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Symbol>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action137(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_3f(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state304(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Symbol0(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state302(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state303(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Symbol(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state301(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Symbol1(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state306(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state305(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 262
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["("]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["*"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["+"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" [";"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["<"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["=>"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["=>?"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["=>@L"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["=>@R"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["?"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["@L"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["@R"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["Escape"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["Id"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["MacroId"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["StringLiteral"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["if"]
    //
    //   ">" -> Shift(S307)
    //
    pub fn __state262<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Symbol>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state307(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 263
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["("]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R [";"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["<"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["=>"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["=>?"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["=>@L"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["=>@R"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["@L"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["@R"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["Escape"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["Id"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["MacroId"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["StringLiteral"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["if"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? (*) ";" @R ["}"]
    //
    //   ";" -> Shift(S308)
    //
    pub fn __state263<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<::std::option::Option<Condition>>,
        __sym3: &mut Option<::std::option::Option<ActionKind>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Semi(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state308(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 264
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) ["{"]
    //
    //   "{" -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //
    pub fn __state264<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 265
    //   (<Conversion> ",") = (*) Conversion "," ["StringLiteral"]
    //   (<Conversion> ",") = (*) Conversion "," ["}"]
    //   (<Conversion> ",")* = (<Conversion> ",")* (*) (<Conversion> ",") ["StringLiteral"]
    //   (<Conversion> ",")* = (<Conversion> ",")* (*) (<Conversion> ",") ["}"]
    //   @L = (*) ["StringLiteral"]
    //   Comma<Conversion> = (<Conversion> ",")* (*) Conversion? ["}"]
    //   Conversion = (*) @L Terminal "=>" @R [","]
    //   Conversion = (*) @L Terminal "=>" @R ["}"]
    //   Conversion? = (*) ["}"]
    //   Conversion? = (*) Conversion ["}"]
    //
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "}" -> Reduce(Conversion? =  => Call(ActionFn(152));)
    //
    //   (<Conversion> ",") -> S312
    //   Conversion -> S310
    //   @L -> S311
    //   Conversion? -> S309
    pub fn __state265<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Conversion>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action152(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Conversion_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cConversion_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state312(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Conversion(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state310(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state311(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Conversion_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state309(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 266
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> (*) "}" AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> (*) "}" AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> (*) "}" AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> (*) "}" AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> (*) "}" AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> (*) "}" AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> (*) "}" AssociatedType* "}" ["use"]
    //
    //   "}" -> Shift(S313)
    //
    pub fn __state266<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
        __sym8: &mut Option<TypeRef>,
        __sym9: &mut Option<usize>,
        __sym10: &mut Option<Tok<'input>>,
        __sym11: &mut Option<Vec<Conversion>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym12 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state313(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 267
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) ["{"]
    //
    //   "{" -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //
    pub fn __state267<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym3: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 268
    //   Escape = "Escape" (*) [";"]
    //
    //   ";" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state268<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 269
    //   AssociatedType = "type" @L Id @R "=" TypeRef (*) ";" ["enum"]
    //   AssociatedType = "type" @L Id @R "=" TypeRef (*) ";" ["type"]
    //
    //   ";" -> Shift(S314)
    //
    pub fn __state269<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Semi(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state314(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 270
    //   (<TypeRef> ",")* = (*) ["&"]
    //   (<TypeRef> ",")* = (*) ["("]
    //   (<TypeRef> ",")* = (*) [")"]
    //   (<TypeRef> ",")* = (*) ["::"]
    //   (<TypeRef> ",")* = (*) ["Escape"]
    //   (<TypeRef> ",")* = (*) ["Id"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (*) (<TypeRef> ",")* TypeRef? [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [";"]
    //
    //   "Escape" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "&" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Id" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   ")" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "::" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "(" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //
    //   (<TypeRef> ",")* -> S60
    //   Comma<TypeRef> -> S315
    pub fn __state270<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state60(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Comma_3cTypeRef_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state315(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 271
    //   TypeRef = Escape (*) [";"]
    //
    //   ";" -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //
    pub fn __state271<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 272
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id [";"]
    //   Path = "::"? (*) (<Id> "::")* Id ["<"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S316
    pub fn __state272<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state316(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 273
    //   Lifetime = (*) "Lifetime" ["&"]
    //   Lifetime = (*) "Lifetime" ["("]
    //   Lifetime = (*) "Lifetime" ["::"]
    //   Lifetime = (*) "Lifetime" ["Escape"]
    //   Lifetime = (*) "Lifetime" ["Id"]
    //   Lifetime = (*) "Lifetime" ["mut"]
    //   Lifetime? = (*) ["&"]
    //   Lifetime? = (*) ["("]
    //   Lifetime? = (*) ["::"]
    //   Lifetime? = (*) ["Escape"]
    //   Lifetime? = (*) ["Id"]
    //   Lifetime? = (*) ["mut"]
    //   Lifetime? = (*) Lifetime ["&"]
    //   Lifetime? = (*) Lifetime ["("]
    //   Lifetime? = (*) Lifetime ["::"]
    //   Lifetime? = (*) Lifetime ["Escape"]
    //   Lifetime? = (*) Lifetime ["Id"]
    //   Lifetime? = (*) Lifetime ["mut"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [";"]
    //
    //   "::" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Id" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "(" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Escape" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Lifetime" -> Shift(S58)
    //   "mut" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "&" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //
    //   Lifetime -> S59
    //   Lifetime? -> S317
    pub fn __state273<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state58(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state59(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Lifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state317(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 274
    //   TypeRef = Path (*) [";"]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [";"]
    //
    //   "<" -> Shift(S318)
    //   ";" -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //
    pub fn __state274<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state318(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 275
    //   StringLiteral = "StringLiteral" (*) [";"]
    //   StringLiteral = "StringLiteral" (*) ["=>"]
    //   StringLiteral = "StringLiteral" (*) ["=>?"]
    //   StringLiteral = "StringLiteral" (*) ["=>@L"]
    //   StringLiteral = "StringLiteral" (*) ["=>@R"]
    //
    //   "=>@L" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "=>" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "=>?" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   ";" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "=>@R" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //
    pub fn __state275<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 276
    //   @R = (*) [";"]
    //   @R = (*) ["=>"]
    //   @R = (*) ["=>?"]
    //   @R = (*) ["=>@L"]
    //   @R = (*) ["=>@R"]
    //   Cond = @L NonterminalId CondOp StringLiteral (*) @R [";"]
    //   Cond = @L NonterminalId CondOp StringLiteral (*) @R ["=>"]
    //   Cond = @L NonterminalId CondOp StringLiteral (*) @R ["=>?"]
    //   Cond = @L NonterminalId CondOp StringLiteral (*) @R ["=>@L"]
    //   Cond = @L NonterminalId CondOp StringLiteral (*) @R ["=>@R"]
    //
    //   "=>?" -> Reduce(@R =  => Lookbehind;)
    //   "=>@L" -> Reduce(@R =  => Lookbehind;)
    //   "=>" -> Reduce(@R =  => Lookbehind;)
    //   ";" -> Reduce(@R =  => Lookbehind;)
    //   "=>@R" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S319
    pub fn __state276<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<NonterminalString>,
        __sym2: &mut Option<ConditionOp>,
        __sym3: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym3.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state319(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 277
    //   @R = (*) ["("]
    //   @R = (*) [")"]
    //   @R = (*) ["*"]
    //   @R = (*) ["+"]
    //   @R = (*) ["<"]
    //   @R = (*) ["?"]
    //   @R = (*) ["@L"]
    //   @R = (*) ["@R"]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["StringLiteral"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["("]
    //   Symbol0 = Symbol0 RepeatOp (*) @R [")"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["*"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["+"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["<"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["?"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["@L"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["@R"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["Escape"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["Id"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["MacroId"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["StringLiteral"]
    //
    //   ")" -> Reduce(@R =  => Lookbehind;)
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //   "+" -> Reduce(@R =  => Lookbehind;)
    //   "@R" -> Reduce(@R =  => Lookbehind;)
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   "StringLiteral" -> Reduce(@R =  => Lookbehind;)
    //   "*" -> Reduce(@R =  => Lookbehind;)
    //   "?" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   "@L" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S320
    pub fn __state277<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
        __sym1: &mut Option<RepeatOp>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Star(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Question(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state320(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 278
    //   RepeatOp = "+" (*) ["("]
    //   RepeatOp = "+" (*) [")"]
    //   RepeatOp = "+" (*) ["*"]
    //   RepeatOp = "+" (*) ["+"]
    //   RepeatOp = "+" (*) ["<"]
    //   RepeatOp = "+" (*) ["?"]
    //   RepeatOp = "+" (*) ["@L"]
    //   RepeatOp = "+" (*) ["@R"]
    //   RepeatOp = "+" (*) ["Escape"]
    //   RepeatOp = "+" (*) ["Id"]
    //   RepeatOp = "+" (*) ["MacroId"]
    //   RepeatOp = "+" (*) ["StringLiteral"]
    //
    //   "*" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "StringLiteral" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "(" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "MacroId" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "@R" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "?" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "Escape" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "@L" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   ")" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "Id" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "+" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "<" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //
    pub fn __state278<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 279
    //   RepeatOp = "*" (*) ["("]
    //   RepeatOp = "*" (*) [")"]
    //   RepeatOp = "*" (*) ["*"]
    //   RepeatOp = "*" (*) ["+"]
    //   RepeatOp = "*" (*) ["<"]
    //   RepeatOp = "*" (*) ["?"]
    //   RepeatOp = "*" (*) ["@L"]
    //   RepeatOp = "*" (*) ["@R"]
    //   RepeatOp = "*" (*) ["Escape"]
    //   RepeatOp = "*" (*) ["Id"]
    //   RepeatOp = "*" (*) ["MacroId"]
    //   RepeatOp = "*" (*) ["StringLiteral"]
    //
    //   "StringLiteral" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "Id" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "+" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "?" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "MacroId" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "@R" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "<" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "@L" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "Escape" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "(" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   ")" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "*" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //
    pub fn __state279<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 280
    //   RepeatOp = "?" (*) ["("]
    //   RepeatOp = "?" (*) [")"]
    //   RepeatOp = "?" (*) ["*"]
    //   RepeatOp = "?" (*) ["+"]
    //   RepeatOp = "?" (*) ["<"]
    //   RepeatOp = "?" (*) ["?"]
    //   RepeatOp = "?" (*) ["@L"]
    //   RepeatOp = "?" (*) ["@R"]
    //   RepeatOp = "?" (*) ["Escape"]
    //   RepeatOp = "?" (*) ["Id"]
    //   RepeatOp = "?" (*) ["MacroId"]
    //   RepeatOp = "?" (*) ["StringLiteral"]
    //
    //   "Id" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "+" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "<" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "*" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "@L" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "StringLiteral" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "(" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "?" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "@R" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "MacroId" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "Escape" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   ")" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //
    pub fn __state280<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 281
    //   ExprSymbol = (*) Symbol* [")"]
    //   Symbol* = (*) ["("]
    //   Symbol* = (*) [")"]
    //   Symbol* = (*) ["<"]
    //   Symbol* = (*) ["@L"]
    //   Symbol* = (*) ["@R"]
    //   Symbol* = (*) ["Escape"]
    //   Symbol* = (*) ["Id"]
    //   Symbol* = (*) ["MacroId"]
    //   Symbol* = (*) ["StringLiteral"]
    //   Symbol* = (*) Symbol* Symbol ["("]
    //   Symbol* = (*) Symbol* Symbol [")"]
    //   Symbol* = (*) Symbol* Symbol ["<"]
    //   Symbol* = (*) Symbol* Symbol ["@L"]
    //   Symbol* = (*) Symbol* Symbol ["@R"]
    //   Symbol* = (*) Symbol* Symbol ["Escape"]
    //   Symbol* = (*) Symbol* Symbol ["Id"]
    //   Symbol* = (*) Symbol* Symbol ["MacroId"]
    //   Symbol* = (*) Symbol* Symbol ["StringLiteral"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["("]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" [")"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["*"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["+"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["<"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["?"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["@L"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["@R"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["Escape"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["Id"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["MacroId"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["StringLiteral"]
    //
    //   "StringLiteral" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@L" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Escape" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "(" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "<" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@R" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   ")" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Id" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "MacroId" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //
    //   ExprSymbol -> S321
    //   Symbol* -> S218
    pub fn __state281<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::ExprSymbol(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state321(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Symbol_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state218(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 282
    //   @L = (*) ["("]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["("]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R [")"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["("]
    //   Symbol = @L "<" (*) Symbol0 ">" @R [")"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R ["StringLiteral"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["*"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["+"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["?"]
    //   Symbol0 = (*) Symbol1 ["*"]
    //   Symbol0 = (*) Symbol1 ["+"]
    //   Symbol0 = (*) Symbol1 [">"]
    //   Symbol0 = (*) Symbol1 ["?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["*"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["+"]
    //   Symbol1 = (*) @L SymbolKind1 @R [">"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["?"]
    //
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //
    //   Symbol1 -> S220
    //   @L -> S323
    //   Symbol0 -> S322
    pub fn __state282<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol1(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state220(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state323(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::Symbol0(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state322(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 283
    //   SymbolKind1 = "@R" (*) ["("]
    //   SymbolKind1 = "@R" (*) [")"]
    //   SymbolKind1 = "@R" (*) ["*"]
    //   SymbolKind1 = "@R" (*) ["+"]
    //   SymbolKind1 = "@R" (*) ["<"]
    //   SymbolKind1 = "@R" (*) ["?"]
    //   SymbolKind1 = "@R" (*) ["@L"]
    //   SymbolKind1 = "@R" (*) ["@R"]
    //   SymbolKind1 = "@R" (*) ["Escape"]
    //   SymbolKind1 = "@R" (*) ["Id"]
    //   SymbolKind1 = "@R" (*) ["MacroId"]
    //   SymbolKind1 = "@R" (*) ["StringLiteral"]
    //
    //   "MacroId" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "Id" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "?" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "Escape" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "@L" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "@R" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "*" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   ")" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "<" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "(" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "+" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //
    pub fn __state283<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 284
    //   @R = (*) ["("]
    //   @R = (*) [")"]
    //   @R = (*) ["*"]
    //   @R = (*) ["+"]
    //   @R = (*) ["<"]
    //   @R = (*) ["?"]
    //   @R = (*) ["@L"]
    //   @R = (*) ["@R"]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["StringLiteral"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["("]
    //   Symbol1 = @L SymbolKind1 (*) @R [")"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["*"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["+"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["<"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["?"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["@L"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["@R"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["Escape"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["Id"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["MacroId"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["StringLiteral"]
    //
    //   "*" -> Reduce(@R =  => Lookbehind;)
    //   "+" -> Reduce(@R =  => Lookbehind;)
    //   "@R" -> Reduce(@R =  => Lookbehind;)
    //   "?" -> Reduce(@R =  => Lookbehind;)
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //   "@L" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   ")" -> Reduce(@R =  => Lookbehind;)
    //   "StringLiteral" -> Reduce(@R =  => Lookbehind;)
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S324
    pub fn __state284<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<SymbolKind>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Question(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state324(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 285
    //   SymbolKind1 = Terminal (*) ["("]
    //   SymbolKind1 = Terminal (*) [")"]
    //   SymbolKind1 = Terminal (*) ["*"]
    //   SymbolKind1 = Terminal (*) ["+"]
    //   SymbolKind1 = Terminal (*) ["<"]
    //   SymbolKind1 = Terminal (*) ["?"]
    //   SymbolKind1 = Terminal (*) ["@L"]
    //   SymbolKind1 = Terminal (*) ["@R"]
    //   SymbolKind1 = Terminal (*) ["Escape"]
    //   SymbolKind1 = Terminal (*) ["Id"]
    //   SymbolKind1 = Terminal (*) ["MacroId"]
    //   SymbolKind1 = Terminal (*) ["StringLiteral"]
    //
    //   "StringLiteral" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   ")" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "+" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "@R" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "Escape" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "MacroId" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "@L" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "<" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "Id" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "*" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "?" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "(" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //
    pub fn __state285<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TerminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 286
    //   StringLiteral = "StringLiteral" (*) ["("]
    //   StringLiteral = "StringLiteral" (*) [")"]
    //   StringLiteral = "StringLiteral" (*) ["*"]
    //   StringLiteral = "StringLiteral" (*) ["+"]
    //   StringLiteral = "StringLiteral" (*) ["<"]
    //   StringLiteral = "StringLiteral" (*) ["?"]
    //   StringLiteral = "StringLiteral" (*) ["@L"]
    //   StringLiteral = "StringLiteral" (*) ["@R"]
    //   StringLiteral = "StringLiteral" (*) ["Escape"]
    //   StringLiteral = "StringLiteral" (*) ["Id"]
    //   StringLiteral = "StringLiteral" (*) ["MacroId"]
    //   StringLiteral = "StringLiteral" (*) ["StringLiteral"]
    //
    //   "Id" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "?" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "*" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "+" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "<" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "(" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "@R" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "Escape" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   ")" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "MacroId" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "@L" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "StringLiteral" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //
    pub fn __state286<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 287
    //   Escape = "Escape" (*) ["("]
    //   Escape = "Escape" (*) [")"]
    //   Escape = "Escape" (*) ["*"]
    //   Escape = "Escape" (*) ["+"]
    //   Escape = "Escape" (*) ["<"]
    //   Escape = "Escape" (*) ["?"]
    //   Escape = "Escape" (*) ["@L"]
    //   Escape = "Escape" (*) ["@R"]
    //   Escape = "Escape" (*) ["Escape"]
    //   Escape = "Escape" (*) ["Id"]
    //   Escape = "Escape" (*) ["MacroId"]
    //   Escape = "Escape" (*) ["StringLiteral"]
    //
    //   "?" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "<" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "Id" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "StringLiteral" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "(" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "@R" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "+" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "Escape" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "MacroId" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "*" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   ")" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "@L" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state287<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 288
    //   SymbolKind1 = "@L" (*) ["("]
    //   SymbolKind1 = "@L" (*) [")"]
    //   SymbolKind1 = "@L" (*) ["*"]
    //   SymbolKind1 = "@L" (*) ["+"]
    //   SymbolKind1 = "@L" (*) ["<"]
    //   SymbolKind1 = "@L" (*) ["?"]
    //   SymbolKind1 = "@L" (*) ["@L"]
    //   SymbolKind1 = "@L" (*) ["@R"]
    //   SymbolKind1 = "@L" (*) ["Escape"]
    //   SymbolKind1 = "@L" (*) ["Id"]
    //   SymbolKind1 = "@L" (*) ["MacroId"]
    //   SymbolKind1 = "@L" (*) ["StringLiteral"]
    //
    //   "@R" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "MacroId" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "@L" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "+" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "<" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "Id" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "(" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "?" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "Escape" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   ")" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "*" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //
    pub fn __state288<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 289
    //   SymbolKind1 = NonterminalId (*) ["("]
    //   SymbolKind1 = NonterminalId (*) [")"]
    //   SymbolKind1 = NonterminalId (*) ["*"]
    //   SymbolKind1 = NonterminalId (*) ["+"]
    //   SymbolKind1 = NonterminalId (*) ["<"]
    //   SymbolKind1 = NonterminalId (*) ["?"]
    //   SymbolKind1 = NonterminalId (*) ["@L"]
    //   SymbolKind1 = NonterminalId (*) ["@R"]
    //   SymbolKind1 = NonterminalId (*) ["Escape"]
    //   SymbolKind1 = NonterminalId (*) ["Id"]
    //   SymbolKind1 = NonterminalId (*) ["MacroId"]
    //   SymbolKind1 = NonterminalId (*) ["StringLiteral"]
    //
    //   "@R" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "Id" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   ")" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "*" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "@L" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "(" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "MacroId" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "Escape" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "+" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "<" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "?" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //
    pub fn __state289<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 290
    //   NonterminalId = Id (*) ["("]
    //   NonterminalId = Id (*) [")"]
    //   NonterminalId = Id (*) ["*"]
    //   NonterminalId = Id (*) ["+"]
    //   NonterminalId = Id (*) ["<"]
    //   NonterminalId = Id (*) ["?"]
    //   NonterminalId = Id (*) ["@L"]
    //   NonterminalId = Id (*) ["@R"]
    //   NonterminalId = Id (*) ["Escape"]
    //   NonterminalId = Id (*) ["Id"]
    //   NonterminalId = Id (*) ["MacroId"]
    //   NonterminalId = Id (*) ["StringLiteral"]
    //
    //   "(" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "<" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "@L" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "+" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   ")" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "Escape" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "Id" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "?" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "@R" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "MacroId" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "*" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "StringLiteral" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //
    pub fn __state290<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 291
    //   Terminal = StringLiteral (*) ["("]
    //   Terminal = StringLiteral (*) [")"]
    //   Terminal = StringLiteral (*) ["*"]
    //   Terminal = StringLiteral (*) ["+"]
    //   Terminal = StringLiteral (*) ["<"]
    //   Terminal = StringLiteral (*) ["?"]
    //   Terminal = StringLiteral (*) ["@L"]
    //   Terminal = StringLiteral (*) ["@R"]
    //   Terminal = StringLiteral (*) ["Escape"]
    //   Terminal = StringLiteral (*) ["Id"]
    //   Terminal = StringLiteral (*) ["MacroId"]
    //   Terminal = StringLiteral (*) ["StringLiteral"]
    //
    //   "StringLiteral" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "@L" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   ")" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "Escape" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "+" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "Id" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "<" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "*" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "?" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "@R" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "MacroId" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "(" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //
    pub fn __state291<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 292
    //   Id = "Id" (*) ["("]
    //   Id = "Id" (*) [")"]
    //   Id = "Id" (*) ["*"]
    //   Id = "Id" (*) ["+"]
    //   Id = "Id" (*) ["<"]
    //   Id = "Id" (*) ["?"]
    //   Id = "Id" (*) ["@L"]
    //   Id = "Id" (*) ["@R"]
    //   Id = "Id" (*) ["Escape"]
    //   Id = "Id" (*) ["Id"]
    //   Id = "Id" (*) ["MacroId"]
    //   Id = "Id" (*) ["StringLiteral"]
    //
    //   ")" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "StringLiteral" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "MacroId" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "+" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "@L" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "(" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "@R" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "Id" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "Escape" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "*" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "?" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state292<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 293
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["("]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" [")"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["<"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["@L"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["@R"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["Escape"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["Id"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["MacroId"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["StringLiteral"]
    //
    //   "<" -> Shift(S325)
    //
    pub fn __state293<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state325(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 294
    //   SymbolKind1 = Escape (*) ["("]
    //   SymbolKind1 = Escape (*) [")"]
    //   SymbolKind1 = Escape (*) ["*"]
    //   SymbolKind1 = Escape (*) ["+"]
    //   SymbolKind1 = Escape (*) ["<"]
    //   SymbolKind1 = Escape (*) ["?"]
    //   SymbolKind1 = Escape (*) ["@L"]
    //   SymbolKind1 = Escape (*) ["@R"]
    //   SymbolKind1 = Escape (*) ["Escape"]
    //   SymbolKind1 = Escape (*) ["Id"]
    //   SymbolKind1 = Escape (*) ["MacroId"]
    //   SymbolKind1 = Escape (*) ["StringLiteral"]
    //
    //   "?" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "*" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "<" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "MacroId" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "@L" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   ")" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "(" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "Escape" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "Id" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "+" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "@R" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //
    pub fn __state294<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 295
    //   (<Symbol> ",")* = (*) ["("]
    //   (<Symbol> ",")* = (*) ["<"]
    //   (<Symbol> ",")* = (*) [">"]
    //   (<Symbol> ",")* = (*) ["@L"]
    //   (<Symbol> ",")* = (*) ["@R"]
    //   (<Symbol> ",")* = (*) ["Escape"]
    //   (<Symbol> ",")* = (*) ["Id"]
    //   (<Symbol> ",")* = (*) ["MacroId"]
    //   (<Symbol> ",")* = (*) ["StringLiteral"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["("]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["<"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") [">"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["@L"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["@R"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["Escape"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["Id"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["MacroId"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["StringLiteral"]
    //   Comma<Symbol> = (*) (<Symbol> ",")* Symbol? [">"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" [">"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["?"]
    //
    //   "<" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "@L" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "MacroId" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "Id" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "StringLiteral" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "(" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "Escape" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "@R" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   ">" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //
    //   (<Symbol> ",")* -> S261
    //   Comma<Symbol> -> S326
    pub fn __state295<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state261(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Comma_3cSymbol_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state326(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 296
    //   @L = (*) ["("]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["("]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R [";"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["=>"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["=>?"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["=>@L"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["=>@R"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["StringLiteral"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["if"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["*"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["+"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["?"]
    //   Symbol0 = (*) Symbol1 ["*"]
    //   Symbol0 = (*) Symbol1 ["+"]
    //   Symbol0 = (*) Symbol1 [">"]
    //   Symbol0 = (*) Symbol1 ["?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["*"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["+"]
    //   Symbol1 = (*) @L SymbolKind1 @R [">"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["?"]
    //
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //
    //   Symbol0 -> S328
    //   Symbol1 -> S220
    //   @L -> S327
    pub fn __state296<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym4.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol0(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state328(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
                }
                __Nonterminal::Symbol1(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state220(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state327(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 297
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["*"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["+"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" [">"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["?"]
    //
    //   ")" -> Shift(S329)
    //
    pub fn __state297<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<ExprSymbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state329(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 298
    //   Symbol1 = @L SymbolKind1 @R (*) ["*"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["+"]
    //   Symbol1 = @L SymbolKind1 @R (*) [">"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["?"]
    //
    //   "?" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   ">" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "*" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "+" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //
    pub fn __state298<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<SymbolKind>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 299
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["*"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["+"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) [">"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["?"]
    //
    //   "+" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "*" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   ">" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "?" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //
    pub fn __state299<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
        __sym1: &mut Option<RepeatOp>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 300
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["("]
    //   Symbol = @L "<" Symbol0 ">" @R (*) [";"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["<"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["=>"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["=>?"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["=>@L"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["=>@R"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["@L"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["@R"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["Escape"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["Id"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["MacroId"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["StringLiteral"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["if"]
    //
    //   "<" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "Escape" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "=>@L" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "=>@R" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "@R" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "=>" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "@L" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "StringLiteral" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "=>?" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "if" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "Id" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   ";" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "MacroId" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "(" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //
    pub fn __state300<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Symbol>,
        __sym3: &mut Option<Tok<'input>>,
        __sym4: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 301
    //   (<Symbol> ",") = Symbol (*) "," ["("]
    //   (<Symbol> ",") = Symbol (*) "," ["<"]
    //   (<Symbol> ",") = Symbol (*) "," [">"]
    //   (<Symbol> ",") = Symbol (*) "," ["@L"]
    //   (<Symbol> ",") = Symbol (*) "," ["@R"]
    //   (<Symbol> ",") = Symbol (*) "," ["Escape"]
    //   (<Symbol> ",") = Symbol (*) "," ["Id"]
    //   (<Symbol> ",") = Symbol (*) "," ["MacroId"]
    //   (<Symbol> ",") = Symbol (*) "," ["StringLiteral"]
    //   Symbol? = Symbol (*) [">"]
    //
    //   ">" -> Reduce(Symbol? = Symbol => Call(ActionFn(136));)
    //   "," -> Shift(S330)
    //
    pub fn __state301<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state330(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action136(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 302
    //   RepeatOp = (*) "*" ["*"]
    //   RepeatOp = (*) "*" ["+"]
    //   RepeatOp = (*) "*" [","]
    //   RepeatOp = (*) "*" [">"]
    //   RepeatOp = (*) "*" ["?"]
    //   RepeatOp = (*) "+" ["*"]
    //   RepeatOp = (*) "+" ["+"]
    //   RepeatOp = (*) "+" [","]
    //   RepeatOp = (*) "+" [">"]
    //   RepeatOp = (*) "+" ["?"]
    //   RepeatOp = (*) "?" ["*"]
    //   RepeatOp = (*) "?" ["+"]
    //   RepeatOp = (*) "?" [","]
    //   RepeatOp = (*) "?" [">"]
    //   RepeatOp = (*) "?" ["?"]
    //   Symbol = Symbol0 (*) [","]
    //   Symbol = Symbol0 (*) [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["*"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["+"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [","]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["?"]
    //
    //   "?" -> Shift(S332)
    //   "*" -> Shift(S333)
    //   "+" -> Shift(S334)
    //   "," -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //   ">" -> Reduce(Symbol = Symbol0 => Call(ActionFn(31));)
    //
    //   RepeatOp -> S331
    pub fn __state302<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Question(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state332(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Star(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state333(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Plus(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state334(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action31(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::RepeatOp(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state331(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 303
    //   (<Symbol> ",")* = (<Symbol> ",")* (<Symbol> ",") (*) ["("]
    //   (<Symbol> ",")* = (<Symbol> ",")* (<Symbol> ",") (*) ["<"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (<Symbol> ",") (*) [">"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (<Symbol> ",") (*) ["@L"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (<Symbol> ",") (*) ["@R"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (<Symbol> ",") (*) ["Escape"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (<Symbol> ",") (*) ["Id"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (<Symbol> ",") (*) ["MacroId"]
    //   (<Symbol> ",")* = (<Symbol> ",")* (<Symbol> ",") (*) ["StringLiteral"]
    //
    //   "<" -> Reduce((<Symbol> ",")* = (<Symbol> ",")*, (<Symbol> ",") => Call(ActionFn(139));)
    //   ">" -> Reduce((<Symbol> ",")* = (<Symbol> ",")*, (<Symbol> ",") => Call(ActionFn(139));)
    //   "@R" -> Reduce((<Symbol> ",")* = (<Symbol> ",")*, (<Symbol> ",") => Call(ActionFn(139));)
    //   "StringLiteral" -> Reduce((<Symbol> ",")* = (<Symbol> ",")*, (<Symbol> ",") => Call(ActionFn(139));)
    //   "Id" -> Reduce((<Symbol> ",")* = (<Symbol> ",")*, (<Symbol> ",") => Call(ActionFn(139));)
    //   "@L" -> Reduce((<Symbol> ",")* = (<Symbol> ",")*, (<Symbol> ",") => Call(ActionFn(139));)
    //   "Escape" -> Reduce((<Symbol> ",")* = (<Symbol> ",")*, (<Symbol> ",") => Call(ActionFn(139));)
    //   "MacroId" -> Reduce((<Symbol> ",")* = (<Symbol> ",")*, (<Symbol> ",") => Call(ActionFn(139));)
    //   "(" -> Reduce((<Symbol> ",")* = (<Symbol> ",")*, (<Symbol> ",") => Call(ActionFn(139));)
    //
    pub fn __state303<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Symbol>>,
        __sym1: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action139(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action139(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action139(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action139(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action139(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action139(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action139(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action139(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action139(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 304
    //   Comma<Symbol> = (<Symbol> ",")* Symbol? (*) [">"]
    //
    //   ">" -> Reduce(Comma<Symbol> = (<Symbol> ",")*, Symbol? => Call(ActionFn(93));)
    //
    pub fn __state304<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Symbol>>,
        __sym1: &mut Option<::std::option::Option<Symbol>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action93(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cSymbol_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 305
    //   Escape = (*) "Escape" ["*"]
    //   Escape = (*) "Escape" ["+"]
    //   Escape = (*) "Escape" [","]
    //   Escape = (*) "Escape" [">"]
    //   Escape = (*) "Escape" ["?"]
    //   Id = (*) "Id" ["*"]
    //   Id = (*) "Id" ["+"]
    //   Id = (*) "Id" [","]
    //   Id = (*) "Id" [">"]
    //   Id = (*) "Id" ["?"]
    //   MacroId = (*) "MacroId" ["<"]
    //   NonterminalId = (*) Id ["*"]
    //   NonterminalId = (*) Id ["+"]
    //   NonterminalId = (*) Id [","]
    //   NonterminalId = (*) Id [">"]
    //   NonterminalId = (*) Id ["?"]
    //   StringLiteral = (*) "StringLiteral" ["*"]
    //   StringLiteral = (*) "StringLiteral" ["+"]
    //   StringLiteral = (*) "StringLiteral" [","]
    //   StringLiteral = (*) "StringLiteral" [">"]
    //   StringLiteral = (*) "StringLiteral" ["?"]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R [","]
    //   Symbol = @L (*) "<" @L Id ":" Symbol0 ">" @R [">"]
    //   Symbol = @L (*) "<" Symbol0 ">" @R [","]
    //   Symbol = @L (*) "<" Symbol0 ">" @R [">"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["*"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["+"]
    //   Symbol1 = @L (*) SymbolKind1 @R [","]
    //   Symbol1 = @L (*) SymbolKind1 @R [">"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["?"]
    //   SymbolKind1 = (*) Escape ["*"]
    //   SymbolKind1 = (*) Escape ["+"]
    //   SymbolKind1 = (*) Escape [","]
    //   SymbolKind1 = (*) Escape [">"]
    //   SymbolKind1 = (*) Escape ["?"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" [","]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" [">"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = (*) NonterminalId ["*"]
    //   SymbolKind1 = (*) NonterminalId ["+"]
    //   SymbolKind1 = (*) NonterminalId [","]
    //   SymbolKind1 = (*) NonterminalId [">"]
    //   SymbolKind1 = (*) NonterminalId ["?"]
    //   SymbolKind1 = (*) Terminal ["*"]
    //   SymbolKind1 = (*) Terminal ["+"]
    //   SymbolKind1 = (*) Terminal [","]
    //   SymbolKind1 = (*) Terminal [">"]
    //   SymbolKind1 = (*) Terminal ["?"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["*"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["+"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" [","]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" [">"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["?"]
    //   SymbolKind1 = (*) "@L" ["*"]
    //   SymbolKind1 = (*) "@L" ["+"]
    //   SymbolKind1 = (*) "@L" [","]
    //   SymbolKind1 = (*) "@L" [">"]
    //   SymbolKind1 = (*) "@L" ["?"]
    //   SymbolKind1 = (*) "@R" ["*"]
    //   SymbolKind1 = (*) "@R" ["+"]
    //   SymbolKind1 = (*) "@R" [","]
    //   SymbolKind1 = (*) "@R" [">"]
    //   SymbolKind1 = (*) "@R" ["?"]
    //   Terminal = (*) StringLiteral ["*"]
    //   Terminal = (*) StringLiteral ["+"]
    //   Terminal = (*) StringLiteral [","]
    //   Terminal = (*) StringLiteral [">"]
    //   Terminal = (*) StringLiteral ["?"]
    //
    //   "Id" -> Shift(S343)
    //   "Escape" -> Shift(S337)
    //   "<" -> Shift(S346)
    //   "MacroId" -> Shift(S68)
    //   "@R" -> Shift(S335)
    //   "StringLiteral" -> Shift(S345)
    //   "(" -> Shift(S344)
    //   "@L" -> Shift(S347)
    //
    //   StringLiteral -> S348
    //   MacroId -> S342
    //   SymbolKind1 -> S339
    //   NonterminalId -> S340
    //   Escape -> S341
    //   Terminal -> S338
    //   Id -> S336
    pub fn __state305<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state343(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state337(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state346(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::MacroId(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Lookbehind(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state335(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::StringLiteral(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state345(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state344(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Lookahead(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state347(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::StringLiteral(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state348(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::MacroId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state342(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::SymbolKind1(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state339(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state340(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state341(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Terminal(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state338(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state336(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 306
    //   Symbol0 = Symbol1 (*) ["*"]
    //   Symbol0 = Symbol1 (*) ["+"]
    //   Symbol0 = Symbol1 (*) [","]
    //   Symbol0 = Symbol1 (*) [">"]
    //   Symbol0 = Symbol1 (*) ["?"]
    //
    //   "," -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "*" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "?" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   ">" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //   "+" -> Reduce(Symbol0 = Symbol1 => Call(ActionFn(32));)
    //
    pub fn __state306<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action32(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 307
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["("]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["*"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["+"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) [";"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["<"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["=>"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["=>?"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["=>@L"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["=>@R"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["?"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["@L"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["@R"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["Escape"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["Id"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["MacroId"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["StringLiteral"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["if"]
    //
    //   "=>" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "if" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "(" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "=>@R" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "Escape" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "MacroId" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "*" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "@L" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "<" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "=>@L" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "Id" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "?" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "=>?" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "@R" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   ";" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "+" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //
    pub fn __state307<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Symbol>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 308
    //   @R = (*) ["("]
    //   @R = (*) [";"]
    //   @R = (*) ["<"]
    //   @R = (*) ["=>"]
    //   @R = (*) ["=>?"]
    //   @R = (*) ["=>@L"]
    //   @R = (*) ["=>@R"]
    //   @R = (*) ["@L"]
    //   @R = (*) ["@R"]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["StringLiteral"]
    //   @R = (*) ["if"]
    //   @R = (*) ["}"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["("]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R [";"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["<"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["=>"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["=>?"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["=>@L"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["=>@R"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["@L"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["@R"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["Escape"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["Id"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["MacroId"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["StringLiteral"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["if"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" (*) @R ["}"]
    //
    //   "@L" -> Reduce(@R =  => Lookbehind;)
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   "=>?" -> Reduce(@R =  => Lookbehind;)
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   "=>" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //   "}" -> Reduce(@R =  => Lookbehind;)
    //   "StringLiteral" -> Reduce(@R =  => Lookbehind;)
    //   "@R" -> Reduce(@R =  => Lookbehind;)
    //   ";" -> Reduce(@R =  => Lookbehind;)
    //   "if" -> Reduce(@R =  => Lookbehind;)
    //   "=>@L" -> Reduce(@R =  => Lookbehind;)
    //   "=>@R" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S349
    pub fn __state308<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<::std::option::Option<Condition>>,
        __sym3: &mut Option<::std::option::Option<ActionKind>>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym4.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state349(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 309
    //   Comma<Conversion> = (<Conversion> ",")* Conversion? (*) ["}"]
    //
    //   "}" -> Reduce(Comma<Conversion> = (<Conversion> ",")*, Conversion? => Call(ActionFn(79));)
    //
    pub fn __state309<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Conversion>>,
        __sym1: &mut Option<::std::option::Option<Conversion>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action79(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cConversion_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 310
    //   (<Conversion> ",") = Conversion (*) "," ["StringLiteral"]
    //   (<Conversion> ",") = Conversion (*) "," ["}"]
    //   Conversion? = Conversion (*) ["}"]
    //
    //   "}" -> Reduce(Conversion? = Conversion => Call(ActionFn(151));)
    //   "," -> Shift(S350)
    //
    pub fn __state310<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Conversion>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state350(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action151(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Conversion_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 311
    //   Conversion = @L (*) Terminal "=>" @R [","]
    //   Conversion = @L (*) Terminal "=>" @R ["}"]
    //   StringLiteral = (*) "StringLiteral" ["=>"]
    //   Terminal = (*) StringLiteral ["=>"]
    //
    //   "StringLiteral" -> Shift(S351)
    //
    //   StringLiteral -> S353
    //   Terminal -> S352
    pub fn __state311<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state351(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::StringLiteral(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state353(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Terminal(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state352(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 312
    //   (<Conversion> ",")* = (<Conversion> ",")* (<Conversion> ",") (*) ["StringLiteral"]
    //   (<Conversion> ",")* = (<Conversion> ",")* (<Conversion> ",") (*) ["}"]
    //
    //   "StringLiteral" -> Reduce((<Conversion> ",")* = (<Conversion> ",")*, (<Conversion> ",") => Call(ActionFn(154));)
    //   "}" -> Reduce((<Conversion> ",")* = (<Conversion> ",")*, (<Conversion> ",") => Call(ActionFn(154));)
    //
    pub fn __state312<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Conversion>>,
        __sym1: &mut Option<Conversion>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action154(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cConversion_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action154(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cConversion_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 313
    //   AssociatedType* = (*) ["type"]
    //   AssociatedType* = (*) ["}"]
    //   AssociatedType* = (*) AssociatedType* AssociatedType ["type"]
    //   AssociatedType* = (*) AssociatedType* AssociatedType ["}"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" (*) AssociatedType* "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" (*) AssociatedType* "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" (*) AssociatedType* "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" (*) AssociatedType* "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" (*) AssociatedType* "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" (*) AssociatedType* "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" (*) AssociatedType* "}" ["use"]
    //
    //   "}" -> Reduce(AssociatedType* =  => Call(ActionFn(80));)
    //   "type" -> Reduce(AssociatedType* =  => Call(ActionFn(80));)
    //
    //   AssociatedType* -> S354
    pub fn __state313<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
        __sym8: &mut Option<TypeRef>,
        __sym9: &mut Option<usize>,
        __sym10: &mut Option<Tok<'input>>,
        __sym11: &mut Option<Vec<Conversion>>,
        __sym12: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action80(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::AssociatedType_2a(__nt));
            }
            Some((_, Tok::Type(..), _)) => {
                let __nt = super::__action80(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::AssociatedType_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym12.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::AssociatedType_2a(__nt) => {
                    let __sym13 = &mut Some(__nt);
                    __result = try!(__state354(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12, __sym13));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 314
    //   AssociatedType = "type" @L Id @R "=" TypeRef ";" (*) ["enum"]
    //   AssociatedType = "type" @L Id @R "=" TypeRef ";" (*) ["type"]
    //
    //   "enum" -> Reduce(AssociatedType = "type", @L, Id, @R, "=", TypeRef, ";" => Call(ActionFn(54));)
    //   "type" -> Reduce(AssociatedType = "type", @L, Id, @R, "=", TypeRef, ";" => Call(ActionFn(54));)
    //
    pub fn __state314<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<TypeRef>,
        __sym6: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Enum(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action54(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::AssociatedType(__nt)));
            }
            Some((_, Tok::Type(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action54(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::AssociatedType(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 315
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [";"]
    //
    //   ")" -> Shift(S355)
    //
    pub fn __state315<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state355(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 316
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" [";"]
    //   Id = (*) "Id" ["<"]
    //   Path = "::"? (<Id> "::")* (*) Id [";"]
    //   Path = "::"? (<Id> "::")* (*) Id ["<"]
    //
    //   "Id" -> Shift(S357)
    //
    //   Id -> S356
    //   (<Id> "::") -> S80
    pub fn __state316<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state357(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state356(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state80(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 317
    //   "mut"? = (*) ["&"]
    //   "mut"? = (*) ["("]
    //   "mut"? = (*) ["::"]
    //   "mut"? = (*) ["Escape"]
    //   "mut"? = (*) ["Id"]
    //   "mut"? = (*) "mut" ["&"]
    //   "mut"? = (*) "mut" ["("]
    //   "mut"? = (*) "mut" ["::"]
    //   "mut"? = (*) "mut" ["Escape"]
    //   "mut"? = (*) "mut" ["Id"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [";"]
    //
    //   "Id" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "&" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "Escape" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "(" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "mut" -> Shift(S73)
    //   "::" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //
    //   "mut"? -> S358
    pub fn __state317<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Mut(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state73(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22mut_22_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state358(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 318
    //   (<TypeRefOrLifetime> ",")* = (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (*) (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? [">"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [";"]
    //
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //
    //   Comma<TypeRefOrLifetime> -> S359
    //   (<TypeRefOrLifetime> ",")* -> S81
    pub fn __state318<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state359(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state81(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 319
    //   Cond = @L NonterminalId CondOp StringLiteral @R (*) [";"]
    //   Cond = @L NonterminalId CondOp StringLiteral @R (*) ["=>"]
    //   Cond = @L NonterminalId CondOp StringLiteral @R (*) ["=>?"]
    //   Cond = @L NonterminalId CondOp StringLiteral @R (*) ["=>@L"]
    //   Cond = @L NonterminalId CondOp StringLiteral @R (*) ["=>@R"]
    //
    //   ";" -> Reduce(Cond = @L, NonterminalId, CondOp, StringLiteral, @R => Call(ActionFn(23));)
    //   "=>@L" -> Reduce(Cond = @L, NonterminalId, CondOp, StringLiteral, @R => Call(ActionFn(23));)
    //   "=>?" -> Reduce(Cond = @L, NonterminalId, CondOp, StringLiteral, @R => Call(ActionFn(23));)
    //   "=>@R" -> Reduce(Cond = @L, NonterminalId, CondOp, StringLiteral, @R => Call(ActionFn(23));)
    //   "=>" -> Reduce(Cond = @L, NonterminalId, CondOp, StringLiteral, @R => Call(ActionFn(23));)
    //
    pub fn __state319<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<NonterminalString>,
        __sym2: &mut Option<ConditionOp>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action23(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Cond(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action23(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Cond(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action23(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Cond(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action23(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Cond(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action23(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Cond(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 320
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["("]
    //   Symbol0 = Symbol0 RepeatOp @R (*) [")"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["*"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["+"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["<"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["?"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["@L"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["@R"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["Escape"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["Id"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["MacroId"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["StringLiteral"]
    //
    //   "Id" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "<" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "@R" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "Escape" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "?" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "(" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   ")" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "@L" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "MacroId" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "StringLiteral" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "+" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "*" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //
    pub fn __state320<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
        __sym1: &mut Option<RepeatOp>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 321
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["("]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" [")"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["*"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["+"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["<"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["?"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["@L"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["@R"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["Escape"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["Id"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["MacroId"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["StringLiteral"]
    //
    //   ")" -> Shift(S360)
    //
    pub fn __state321<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<ExprSymbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state360(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 322
    //   RepeatOp = (*) "*" ["*"]
    //   RepeatOp = (*) "*" ["+"]
    //   RepeatOp = (*) "*" [">"]
    //   RepeatOp = (*) "*" ["?"]
    //   RepeatOp = (*) "+" ["*"]
    //   RepeatOp = (*) "+" ["+"]
    //   RepeatOp = (*) "+" [">"]
    //   RepeatOp = (*) "+" ["?"]
    //   RepeatOp = (*) "?" ["*"]
    //   RepeatOp = (*) "?" ["+"]
    //   RepeatOp = (*) "?" [">"]
    //   RepeatOp = (*) "?" ["?"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["("]
    //   Symbol = @L "<" Symbol0 (*) ">" @R [")"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["<"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["@L"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["@R"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["Escape"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["Id"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["MacroId"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R ["StringLiteral"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["*"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["+"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["?"]
    //
    //   "+" -> Shift(S260)
    //   "?" -> Shift(S259)
    //   "*" -> Shift(S257)
    //   ">" -> Shift(S361)
    //
    //   RepeatOp -> S256
    pub fn __state322<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Plus(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state260(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Question(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state259(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Star(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state257(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state361(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::RepeatOp(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state256(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 323
    //   Escape = (*) "Escape" ["*"]
    //   Escape = (*) "Escape" ["+"]
    //   Escape = (*) "Escape" [">"]
    //   Escape = (*) "Escape" ["?"]
    //   Id = (*) "Id" ["*"]
    //   Id = (*) "Id" ["+"]
    //   Id = (*) "Id" [":"]
    //   Id = (*) "Id" [">"]
    //   Id = (*) "Id" ["?"]
    //   MacroId = (*) "MacroId" ["<"]
    //   NonterminalId = (*) Id ["*"]
    //   NonterminalId = (*) Id ["+"]
    //   NonterminalId = (*) Id [">"]
    //   NonterminalId = (*) Id ["?"]
    //   StringLiteral = (*) "StringLiteral" ["*"]
    //   StringLiteral = (*) "StringLiteral" ["+"]
    //   StringLiteral = (*) "StringLiteral" [">"]
    //   StringLiteral = (*) "StringLiteral" ["?"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["("]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R [")"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R ["StringLiteral"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["*"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["+"]
    //   Symbol1 = @L (*) SymbolKind1 @R [">"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["?"]
    //   SymbolKind1 = (*) Escape ["*"]
    //   SymbolKind1 = (*) Escape ["+"]
    //   SymbolKind1 = (*) Escape [">"]
    //   SymbolKind1 = (*) Escape ["?"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" [">"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = (*) NonterminalId ["*"]
    //   SymbolKind1 = (*) NonterminalId ["+"]
    //   SymbolKind1 = (*) NonterminalId [">"]
    //   SymbolKind1 = (*) NonterminalId ["?"]
    //   SymbolKind1 = (*) Terminal ["*"]
    //   SymbolKind1 = (*) Terminal ["+"]
    //   SymbolKind1 = (*) Terminal [">"]
    //   SymbolKind1 = (*) Terminal ["?"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["*"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["+"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" [">"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["?"]
    //   SymbolKind1 = (*) "@L" ["*"]
    //   SymbolKind1 = (*) "@L" ["+"]
    //   SymbolKind1 = (*) "@L" [">"]
    //   SymbolKind1 = (*) "@L" ["?"]
    //   SymbolKind1 = (*) "@R" ["*"]
    //   SymbolKind1 = (*) "@R" ["+"]
    //   SymbolKind1 = (*) "@R" [">"]
    //   SymbolKind1 = (*) "@R" ["?"]
    //   Terminal = (*) StringLiteral ["*"]
    //   Terminal = (*) StringLiteral ["+"]
    //   Terminal = (*) StringLiteral [">"]
    //   Terminal = (*) StringLiteral ["?"]
    //
    //   "Escape" -> Shift(S250)
    //   "@R" -> Shift(S255)
    //   "MacroId" -> Shift(S68)
    //   "Id" -> Shift(S249)
    //   "(" -> Shift(S248)
    //   "@L" -> Shift(S246)
    //   "StringLiteral" -> Shift(S244)
    //
    //   NonterminalId -> S254
    //   SymbolKind1 -> S251
    //   Terminal -> S243
    //   StringLiteral -> S253
    //   MacroId -> S245
    //   Escape -> S252
    //   Id -> S362
    pub fn __state323<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state250(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Lookbehind(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state255(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::MacroId(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state249(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state248(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Lookahead(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state246(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::StringLiteral(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state244(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state254(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::SymbolKind1(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state251(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
                }
                __Nonterminal::Terminal(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state243(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::StringLiteral(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state253(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::MacroId(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state245(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state252(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state362(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 324
    //   Symbol1 = @L SymbolKind1 @R (*) ["("]
    //   Symbol1 = @L SymbolKind1 @R (*) [")"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["*"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["+"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["<"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["?"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["@L"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["@R"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["Escape"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["Id"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["MacroId"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["StringLiteral"]
    //
    //   "+" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   ")" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "*" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "(" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "StringLiteral" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "<" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "MacroId" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "Escape" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "?" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "@L" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "@R" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "Id" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //
    pub fn __state324<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<SymbolKind>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 325
    //   (<Symbol> ",")* = (*) ["("]
    //   (<Symbol> ",")* = (*) ["<"]
    //   (<Symbol> ",")* = (*) [">"]
    //   (<Symbol> ",")* = (*) ["@L"]
    //   (<Symbol> ",")* = (*) ["@R"]
    //   (<Symbol> ",")* = (*) ["Escape"]
    //   (<Symbol> ",")* = (*) ["Id"]
    //   (<Symbol> ",")* = (*) ["MacroId"]
    //   (<Symbol> ",")* = (*) ["StringLiteral"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["("]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["<"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") [">"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["@L"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["@R"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["Escape"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["Id"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["MacroId"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["StringLiteral"]
    //   Comma<Symbol> = (*) (<Symbol> ",")* Symbol? [">"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["("]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" [")"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["<"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["@L"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["@R"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["Escape"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["Id"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["MacroId"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["StringLiteral"]
    //
    //   "@L" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "MacroId" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "(" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "@R" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "<" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   ">" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "Escape" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "Id" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "StringLiteral" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //
    //   (<Symbol> ",")* -> S261
    //   Comma<Symbol> -> S363
    pub fn __state325<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state261(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Comma_3cSymbol_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state363(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 326
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["*"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["+"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" [">"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["?"]
    //
    //   ">" -> Shift(S364)
    //
    pub fn __state326<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Symbol>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state364(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 327
    //   Escape = (*) "Escape" ["*"]
    //   Escape = (*) "Escape" ["+"]
    //   Escape = (*) "Escape" [">"]
    //   Escape = (*) "Escape" ["?"]
    //   Id = (*) "Id" ["*"]
    //   Id = (*) "Id" ["+"]
    //   Id = (*) "Id" [">"]
    //   Id = (*) "Id" ["?"]
    //   MacroId = (*) "MacroId" ["<"]
    //   NonterminalId = (*) Id ["*"]
    //   NonterminalId = (*) Id ["+"]
    //   NonterminalId = (*) Id [">"]
    //   NonterminalId = (*) Id ["?"]
    //   StringLiteral = (*) "StringLiteral" ["*"]
    //   StringLiteral = (*) "StringLiteral" ["+"]
    //   StringLiteral = (*) "StringLiteral" [">"]
    //   StringLiteral = (*) "StringLiteral" ["?"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["*"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["+"]
    //   Symbol1 = @L (*) SymbolKind1 @R [">"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["?"]
    //   SymbolKind1 = (*) Escape ["*"]
    //   SymbolKind1 = (*) Escape ["+"]
    //   SymbolKind1 = (*) Escape [">"]
    //   SymbolKind1 = (*) Escape ["?"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" [">"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = (*) NonterminalId ["*"]
    //   SymbolKind1 = (*) NonterminalId ["+"]
    //   SymbolKind1 = (*) NonterminalId [">"]
    //   SymbolKind1 = (*) NonterminalId ["?"]
    //   SymbolKind1 = (*) Terminal ["*"]
    //   SymbolKind1 = (*) Terminal ["+"]
    //   SymbolKind1 = (*) Terminal [">"]
    //   SymbolKind1 = (*) Terminal ["?"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["*"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["+"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" [">"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["?"]
    //   SymbolKind1 = (*) "@L" ["*"]
    //   SymbolKind1 = (*) "@L" ["+"]
    //   SymbolKind1 = (*) "@L" [">"]
    //   SymbolKind1 = (*) "@L" ["?"]
    //   SymbolKind1 = (*) "@R" ["*"]
    //   SymbolKind1 = (*) "@R" ["+"]
    //   SymbolKind1 = (*) "@R" [">"]
    //   SymbolKind1 = (*) "@R" ["?"]
    //   Terminal = (*) StringLiteral ["*"]
    //   Terminal = (*) StringLiteral ["+"]
    //   Terminal = (*) StringLiteral [">"]
    //   Terminal = (*) StringLiteral ["?"]
    //
    //   "(" -> Shift(S248)
    //   "@R" -> Shift(S255)
    //   "Escape" -> Shift(S250)
    //   "Id" -> Shift(S365)
    //   "@L" -> Shift(S246)
    //   "StringLiteral" -> Shift(S244)
    //   "MacroId" -> Shift(S68)
    //
    //   SymbolKind1 -> S251
    //   Terminal -> S243
    //   NonterminalId -> S254
    //   Id -> S366
    //   Escape -> S252
    //   MacroId -> S245
    //   StringLiteral -> S253
    pub fn __state327<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state248(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Lookbehind(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state255(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state250(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state365(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Lookahead(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state246(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::StringLiteral(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state244(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::MacroId(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::SymbolKind1(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state251(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Terminal(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state243(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state254(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state366(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state252(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::MacroId(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state245(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::StringLiteral(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state253(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 328
    //   RepeatOp = (*) "*" ["*"]
    //   RepeatOp = (*) "*" ["+"]
    //   RepeatOp = (*) "*" [">"]
    //   RepeatOp = (*) "*" ["?"]
    //   RepeatOp = (*) "+" ["*"]
    //   RepeatOp = (*) "+" ["+"]
    //   RepeatOp = (*) "+" [">"]
    //   RepeatOp = (*) "+" ["?"]
    //   RepeatOp = (*) "?" ["*"]
    //   RepeatOp = (*) "?" ["+"]
    //   RepeatOp = (*) "?" [">"]
    //   RepeatOp = (*) "?" ["?"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["("]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R [";"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["<"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["=>"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["=>?"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["=>@L"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["=>@R"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["@L"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["@R"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["Escape"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["Id"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["MacroId"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["StringLiteral"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["if"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["*"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["+"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["?"]
    //
    //   "?" -> Shift(S259)
    //   ">" -> Shift(S367)
    //   "+" -> Shift(S260)
    //   "*" -> Shift(S257)
    //
    //   RepeatOp -> S256
    pub fn __state328<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Question(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state259(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state367(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6));
            }
            Some((_, __tok @ Tok::Plus(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state260(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, __tok @ Tok::Star(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state257(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym5.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::RepeatOp(__nt) => {
                    let __sym6 = &mut Some(__nt);
                    __result = try!(__state256(text, __lookbehind, __lookahead, __tokens, __sym5, __sym6));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 329
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["*"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["+"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) [">"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["?"]
    //
    //   "+" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "*" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "?" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   ">" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //
    pub fn __state329<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 330
    //   (<Symbol> ",") = Symbol "," (*) ["("]
    //   (<Symbol> ",") = Symbol "," (*) ["<"]
    //   (<Symbol> ",") = Symbol "," (*) [">"]
    //   (<Symbol> ",") = Symbol "," (*) ["@L"]
    //   (<Symbol> ",") = Symbol "," (*) ["@R"]
    //   (<Symbol> ",") = Symbol "," (*) ["Escape"]
    //   (<Symbol> ",") = Symbol "," (*) ["Id"]
    //   (<Symbol> ",") = Symbol "," (*) ["MacroId"]
    //   (<Symbol> ",") = Symbol "," (*) ["StringLiteral"]
    //
    //   ">" -> Reduce((<Symbol> ",") = Symbol, "," => Call(ActionFn(140));)
    //   "(" -> Reduce((<Symbol> ",") = Symbol, "," => Call(ActionFn(140));)
    //   "Escape" -> Reduce((<Symbol> ",") = Symbol, "," => Call(ActionFn(140));)
    //   "MacroId" -> Reduce((<Symbol> ",") = Symbol, "," => Call(ActionFn(140));)
    //   "Id" -> Reduce((<Symbol> ",") = Symbol, "," => Call(ActionFn(140));)
    //   "@R" -> Reduce((<Symbol> ",") = Symbol, "," => Call(ActionFn(140));)
    //   "<" -> Reduce((<Symbol> ",") = Symbol, "," => Call(ActionFn(140));)
    //   "StringLiteral" -> Reduce((<Symbol> ",") = Symbol, "," => Call(ActionFn(140));)
    //   "@L" -> Reduce((<Symbol> ",") = Symbol, "," => Call(ActionFn(140));)
    //
    pub fn __state330<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action140(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action140(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action140(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action140(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action140(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action140(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action140(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action140(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action140(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 331
    //   @R = (*) ["*"]
    //   @R = (*) ["+"]
    //   @R = (*) [","]
    //   @R = (*) [">"]
    //   @R = (*) ["?"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["*"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["+"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R [","]
    //   Symbol0 = Symbol0 RepeatOp (*) @R [">"]
    //   Symbol0 = Symbol0 RepeatOp (*) @R ["?"]
    //
    //   ">" -> Reduce(@R =  => Lookbehind;)
    //   "," -> Reduce(@R =  => Lookbehind;)
    //   "+" -> Reduce(@R =  => Lookbehind;)
    //   "?" -> Reduce(@R =  => Lookbehind;)
    //   "*" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S368
    pub fn __state331<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
        __sym1: &mut Option<RepeatOp>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Question(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Star(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state368(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 332
    //   RepeatOp = "?" (*) ["*"]
    //   RepeatOp = "?" (*) ["+"]
    //   RepeatOp = "?" (*) [","]
    //   RepeatOp = "?" (*) [">"]
    //   RepeatOp = "?" (*) ["?"]
    //
    //   "?" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   ">" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "+" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "*" -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //   "," -> Reduce(RepeatOp = "?" => Call(ActionFn(36));)
    //
    pub fn __state332<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action36(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 333
    //   RepeatOp = "*" (*) ["*"]
    //   RepeatOp = "*" (*) ["+"]
    //   RepeatOp = "*" (*) [","]
    //   RepeatOp = "*" (*) [">"]
    //   RepeatOp = "*" (*) ["?"]
    //
    //   "*" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "," -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "+" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   "?" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //   ">" -> Reduce(RepeatOp = "*" => Call(ActionFn(35));)
    //
    pub fn __state333<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action35(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 334
    //   RepeatOp = "+" (*) ["*"]
    //   RepeatOp = "+" (*) ["+"]
    //   RepeatOp = "+" (*) [","]
    //   RepeatOp = "+" (*) [">"]
    //   RepeatOp = "+" (*) ["?"]
    //
    //   "," -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   ">" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "*" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "?" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //   "+" -> Reduce(RepeatOp = "+" => Call(ActionFn(34));)
    //
    pub fn __state334<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action34(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::RepeatOp(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 335
    //   SymbolKind1 = "@R" (*) ["*"]
    //   SymbolKind1 = "@R" (*) ["+"]
    //   SymbolKind1 = "@R" (*) [","]
    //   SymbolKind1 = "@R" (*) [">"]
    //   SymbolKind1 = "@R" (*) ["?"]
    //
    //   "*" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "+" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "," -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   ">" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //   "?" -> Reduce(SymbolKind1 = "@R" => Call(ActionFn(44));)
    //
    pub fn __state335<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action44(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 336
    //   NonterminalId = Id (*) ["*"]
    //   NonterminalId = Id (*) ["+"]
    //   NonterminalId = Id (*) [","]
    //   NonterminalId = Id (*) [">"]
    //   NonterminalId = Id (*) ["?"]
    //
    //   ">" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "+" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "," -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "?" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "*" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //
    pub fn __state336<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 337
    //   Escape = "Escape" (*) ["*"]
    //   Escape = "Escape" (*) ["+"]
    //   Escape = "Escape" (*) [","]
    //   Escape = "Escape" (*) [">"]
    //   Escape = "Escape" (*) ["?"]
    //
    //   ">" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "," -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "?" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "*" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   "+" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state337<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 338
    //   SymbolKind1 = Terminal (*) ["*"]
    //   SymbolKind1 = Terminal (*) ["+"]
    //   SymbolKind1 = Terminal (*) [","]
    //   SymbolKind1 = Terminal (*) [">"]
    //   SymbolKind1 = Terminal (*) ["?"]
    //
    //   "*" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "?" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "+" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   ">" -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //   "," -> Reduce(SymbolKind1 = Terminal => Call(ActionFn(39));)
    //
    pub fn __state338<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TerminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action39(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 339
    //   @R = (*) ["*"]
    //   @R = (*) ["+"]
    //   @R = (*) [","]
    //   @R = (*) [">"]
    //   @R = (*) ["?"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["*"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["+"]
    //   Symbol1 = @L SymbolKind1 (*) @R [","]
    //   Symbol1 = @L SymbolKind1 (*) @R [">"]
    //   Symbol1 = @L SymbolKind1 (*) @R ["?"]
    //
    //   "," -> Reduce(@R =  => Lookbehind;)
    //   "+" -> Reduce(@R =  => Lookbehind;)
    //   ">" -> Reduce(@R =  => Lookbehind;)
    //   "*" -> Reduce(@R =  => Lookbehind;)
    //   "?" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S369
    pub fn __state339<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<SymbolKind>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Star(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Question(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state369(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 340
    //   SymbolKind1 = NonterminalId (*) ["*"]
    //   SymbolKind1 = NonterminalId (*) ["+"]
    //   SymbolKind1 = NonterminalId (*) [","]
    //   SymbolKind1 = NonterminalId (*) [">"]
    //   SymbolKind1 = NonterminalId (*) ["?"]
    //
    //   "*" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "?" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "+" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   "," -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //   ">" -> Reduce(SymbolKind1 = NonterminalId => Call(ActionFn(40));)
    //
    pub fn __state340<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action40(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 341
    //   SymbolKind1 = Escape (*) ["*"]
    //   SymbolKind1 = Escape (*) ["+"]
    //   SymbolKind1 = Escape (*) [","]
    //   SymbolKind1 = Escape (*) [">"]
    //   SymbolKind1 = Escape (*) ["?"]
    //
    //   "*" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "," -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   ">" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "+" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //   "?" -> Reduce(SymbolKind1 = Escape => Call(ActionFn(41));)
    //
    pub fn __state341<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action41(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 342
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" [","]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" [">"]
    //   SymbolKind1 = MacroId (*) "<" Comma<Symbol> ">" ["?"]
    //
    //   "<" -> Shift(S370)
    //
    pub fn __state342<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state370(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 343
    //   Id = "Id" (*) ["*"]
    //   Id = "Id" (*) ["+"]
    //   Id = "Id" (*) [","]
    //   Id = "Id" (*) [">"]
    //   Id = "Id" (*) ["?"]
    //
    //   "*" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "?" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "," -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "+" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   ">" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state343<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 344
    //   ExprSymbol = (*) Symbol* [")"]
    //   Symbol* = (*) ["("]
    //   Symbol* = (*) [")"]
    //   Symbol* = (*) ["<"]
    //   Symbol* = (*) ["@L"]
    //   Symbol* = (*) ["@R"]
    //   Symbol* = (*) ["Escape"]
    //   Symbol* = (*) ["Id"]
    //   Symbol* = (*) ["MacroId"]
    //   Symbol* = (*) ["StringLiteral"]
    //   Symbol* = (*) Symbol* Symbol ["("]
    //   Symbol* = (*) Symbol* Symbol [")"]
    //   Symbol* = (*) Symbol* Symbol ["<"]
    //   Symbol* = (*) Symbol* Symbol ["@L"]
    //   Symbol* = (*) Symbol* Symbol ["@R"]
    //   Symbol* = (*) Symbol* Symbol ["Escape"]
    //   Symbol* = (*) Symbol* Symbol ["Id"]
    //   Symbol* = (*) Symbol* Symbol ["MacroId"]
    //   Symbol* = (*) Symbol* Symbol ["StringLiteral"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["*"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["+"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" [","]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" [">"]
    //   SymbolKind1 = "(" (*) ExprSymbol ")" ["?"]
    //
    //   "Id" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   ")" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "MacroId" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@R" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "<" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "(" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "Escape" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "StringLiteral" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //   "@L" -> Reduce(Symbol* =  => Call(ActionFn(94));)
    //
    //   Symbol* -> S218
    //   ExprSymbol -> S371
    pub fn __state344<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action94(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Symbol_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state218(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::ExprSymbol(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state371(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 345
    //   StringLiteral = "StringLiteral" (*) ["*"]
    //   StringLiteral = "StringLiteral" (*) ["+"]
    //   StringLiteral = "StringLiteral" (*) [","]
    //   StringLiteral = "StringLiteral" (*) [">"]
    //   StringLiteral = "StringLiteral" (*) ["?"]
    //
    //   "*" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   ">" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "+" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "?" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //   "," -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //
    pub fn __state345<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 346
    //   @L = (*) ["("]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R [","]
    //   Symbol = @L "<" (*) @L Id ":" Symbol0 ">" @R [">"]
    //   Symbol = @L "<" (*) Symbol0 ">" @R [","]
    //   Symbol = @L "<" (*) Symbol0 ">" @R [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["*"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["+"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["?"]
    //   Symbol0 = (*) Symbol1 ["*"]
    //   Symbol0 = (*) Symbol1 ["+"]
    //   Symbol0 = (*) Symbol1 [">"]
    //   Symbol0 = (*) Symbol1 ["?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["*"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["+"]
    //   Symbol1 = (*) @L SymbolKind1 @R [">"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["?"]
    //
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //
    //   @L -> S373
    //   Symbol1 -> S220
    //   Symbol0 -> S372
    pub fn __state346<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state373(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::Symbol1(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state220(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Symbol0(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state372(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 347
    //   SymbolKind1 = "@L" (*) ["*"]
    //   SymbolKind1 = "@L" (*) ["+"]
    //   SymbolKind1 = "@L" (*) [","]
    //   SymbolKind1 = "@L" (*) [">"]
    //   SymbolKind1 = "@L" (*) ["?"]
    //
    //   "+" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   ">" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "," -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "*" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //   "?" -> Reduce(SymbolKind1 = "@L" => Call(ActionFn(43));)
    //
    pub fn __state347<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action43(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 348
    //   Terminal = StringLiteral (*) ["*"]
    //   Terminal = StringLiteral (*) ["+"]
    //   Terminal = StringLiteral (*) [","]
    //   Terminal = StringLiteral (*) [">"]
    //   Terminal = StringLiteral (*) ["?"]
    //
    //   ">" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "," -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "*" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "+" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //   "?" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //
    pub fn __state348<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 349
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["("]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) [";"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["<"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["=>"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["=>?"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["=>@L"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["=>@R"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["@L"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["@R"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["Escape"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["Id"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["MacroId"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["StringLiteral"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["if"]
    //   Alternative = @L ExprSymbol ("if" <Cond>)? Action? ";" @R (*) ["}"]
    //
    //   "@R" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "Id" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "}" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "MacroId" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "Escape" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   ";" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "(" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "=>" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "@L" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "=>?" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "=>@R" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "<" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "StringLiteral" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "=>@L" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //   "if" -> Reduce(Alternative = @L, ExprSymbol, ("if" <Cond>)?, Action?, ";", @R => Call(ActionFn(18));)
    //
    pub fn __state349<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<::std::option::Option<Condition>>,
        __sym3: &mut Option<::std::option::Option<ActionKind>>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __nt = super::__action18(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Alternative(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 350
    //   (<Conversion> ",") = Conversion "," (*) ["StringLiteral"]
    //   (<Conversion> ",") = Conversion "," (*) ["}"]
    //
    //   "}" -> Reduce((<Conversion> ",") = Conversion, "," => Call(ActionFn(155));)
    //   "StringLiteral" -> Reduce((<Conversion> ",") = Conversion, "," => Call(ActionFn(155));)
    //
    pub fn __state350<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Conversion>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action155(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cConversion_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action155(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cConversion_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 351
    //   StringLiteral = "StringLiteral" (*) ["=>"]
    //
    //   "=>" -> Reduce(StringLiteral = "StringLiteral" => Call(ActionFn(72));)
    //
    pub fn __state351<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action72(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::StringLiteral(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 352
    //   Conversion = @L Terminal (*) "=>" @R [","]
    //   Conversion = @L Terminal (*) "=>" @R ["}"]
    //
    //   "=>" -> Shift(S374)
    //
    pub fn __state352<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<TerminalString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanCode(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state374(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 353
    //   Terminal = StringLiteral (*) ["=>"]
    //
    //   "=>" -> Reduce(Terminal = StringLiteral => Call(ActionFn(71));)
    //
    pub fn __state353<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action71(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Terminal(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 354
    //   AssociatedType = (*) "type" @L Id @R "=" TypeRef ";" ["type"]
    //   AssociatedType = (*) "type" @L Id @R "=" TypeRef ";" ["}"]
    //   AssociatedType* = AssociatedType* (*) AssociatedType ["type"]
    //   AssociatedType* = AssociatedType* (*) AssociatedType ["}"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* (*) "}" [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* (*) "}" ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* (*) "}" ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* (*) "}" ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* (*) "}" ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* (*) "}" ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* (*) "}" ["use"]
    //
    //   "type" -> Shift(S377)
    //   "}" -> Shift(S376)
    //
    //   AssociatedType -> S375
    pub fn __state354<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
        __sym8: &mut Option<TypeRef>,
        __sym9: &mut Option<usize>,
        __sym10: &mut Option<Tok<'input>>,
        __sym11: &mut Option<Vec<Conversion>>,
        __sym12: &mut Option<Tok<'input>>,
        __sym13: &mut Option<::std::vec::Vec<AssociatedType>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Type(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym14 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state377(text, __lookbehind, __lookahead, __tokens, __sym14));
            }
            Some((_, __tok @ Tok::RightBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym14 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state376(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12, __sym13, __sym14));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym13.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::AssociatedType(__nt) => {
                    let __sym14 = &mut Some(__nt);
                    __result = try!(__state375(text, __lookbehind, __lookahead, __tokens, __sym13, __sym14));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 355
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [";"]
    //
    //   ";" -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //
    pub fn __state355<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 356
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) [";"]
    //   Path = "::"? (<Id> "::")* Id (*) ["<"]
    //
    //   ";" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "<" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S88)
    //
    pub fn __state356<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state88(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 357
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) [";"]
    //   Id = "Id" (*) ["<"]
    //
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   ";" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state357<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 358
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [";"]
    //   Path = (*) "::"? (<Id> "::")* Id [";"]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   TypeRef = (*) Escape [";"]
    //   TypeRef = (*) Path [";"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [";"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [";"]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [";"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [";"]
    //
    //   "::" -> Shift(S50)
    //   "Escape" -> Shift(S268)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "(" -> Shift(S270)
    //   "&" -> Shift(S273)
    //
    //   "::"? -> S272
    //   Escape -> S271
    //   Path -> S274
    //   TypeRef -> S378
    pub fn __state358<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state268(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state270(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state273(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state272(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state271(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state274(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state378(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 359
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [";"]
    //
    //   ">" -> Shift(S379)
    //
    pub fn __state359<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state379(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 360
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["("]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) [")"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["*"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["+"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["<"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["?"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["@L"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["@R"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["Escape"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["Id"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["MacroId"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["StringLiteral"]
    //
    //   "+" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "Id" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "(" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "@R" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "MacroId" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "Escape" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "@L" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "StringLiteral" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "<" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   ")" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "*" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "?" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //
    pub fn __state360<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 361
    //   @R = (*) ["("]
    //   @R = (*) [")"]
    //   @R = (*) ["<"]
    //   @R = (*) ["@L"]
    //   @R = (*) ["@R"]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["StringLiteral"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["("]
    //   Symbol = @L "<" Symbol0 ">" (*) @R [")"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["<"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["@L"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["@R"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["Escape"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["Id"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["MacroId"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R ["StringLiteral"]
    //
    //   ")" -> Reduce(@R =  => Lookbehind;)
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   "StringLiteral" -> Reduce(@R =  => Lookbehind;)
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //   "@R" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //   "@L" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S380
    pub fn __state361<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Symbol>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym3.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state380(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 362
    //   NonterminalId = Id (*) ["*"]
    //   NonterminalId = Id (*) ["+"]
    //   NonterminalId = Id (*) [">"]
    //   NonterminalId = Id (*) ["?"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["("]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R [")"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R ["StringLiteral"]
    //
    //   "+" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "*" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "?" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   ">" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   ":" -> Shift(S381)
    //
    pub fn __state362<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Colon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state381(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 363
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["("]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" [")"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["*"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["+"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["<"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["?"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["@L"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["@R"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["Escape"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["Id"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["MacroId"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["StringLiteral"]
    //
    //   ">" -> Shift(S382)
    //
    pub fn __state363<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Symbol>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state382(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 364
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["*"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["+"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) [">"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["?"]
    //
    //   "?" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   ">" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "*" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "+" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //
    pub fn __state364<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Symbol>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 365
    //   Id = "Id" (*) ["*"]
    //   Id = "Id" (*) ["+"]
    //   Id = "Id" (*) [">"]
    //   Id = "Id" (*) ["?"]
    //
    //   "?" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "+" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   ">" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "*" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state365<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 366
    //   NonterminalId = Id (*) ["*"]
    //   NonterminalId = Id (*) ["+"]
    //   NonterminalId = Id (*) [">"]
    //   NonterminalId = Id (*) ["?"]
    //
    //   "+" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "*" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   ">" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "?" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //
    pub fn __state366<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action67(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 367
    //   @R = (*) ["("]
    //   @R = (*) [";"]
    //   @R = (*) ["<"]
    //   @R = (*) ["=>"]
    //   @R = (*) ["=>?"]
    //   @R = (*) ["=>@L"]
    //   @R = (*) ["=>@R"]
    //   @R = (*) ["@L"]
    //   @R = (*) ["@R"]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["StringLiteral"]
    //   @R = (*) ["if"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["("]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R [";"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["<"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["=>"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["=>?"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["=>@L"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["=>@R"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["@L"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["@R"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["Escape"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["Id"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["MacroId"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["StringLiteral"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["if"]
    //
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   "=>?" -> Reduce(@R =  => Lookbehind;)
    //   "=>@R" -> Reduce(@R =  => Lookbehind;)
    //   "if" -> Reduce(@R =  => Lookbehind;)
    //   ";" -> Reduce(@R =  => Lookbehind;)
    //   "@L" -> Reduce(@R =  => Lookbehind;)
    //   "StringLiteral" -> Reduce(@R =  => Lookbehind;)
    //   "@R" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   "=>" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //   "=>@L" -> Reduce(@R =  => Lookbehind;)
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S383
    pub fn __state367<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<Symbol>,
        __sym6: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::If(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Semi(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym6.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym7 = &mut Some(__nt);
                    __result = try!(__state383(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 368
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["*"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["+"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) [","]
    //   Symbol0 = Symbol0 RepeatOp @R (*) [">"]
    //   Symbol0 = Symbol0 RepeatOp @R (*) ["?"]
    //
    //   "+" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "," -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "?" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   "*" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //   ">" -> Reduce(Symbol0 = Symbol0, RepeatOp, @R => Call(ActionFn(33));)
    //
    pub fn __state368<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Symbol>,
        __sym1: &mut Option<RepeatOp>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action33(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol0(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 369
    //   Symbol1 = @L SymbolKind1 @R (*) ["*"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["+"]
    //   Symbol1 = @L SymbolKind1 @R (*) [","]
    //   Symbol1 = @L SymbolKind1 @R (*) [">"]
    //   Symbol1 = @L SymbolKind1 @R (*) ["?"]
    //
    //   "+" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   ">" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "*" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "?" -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //   "," -> Reduce(Symbol1 = @L, SymbolKind1, @R => Call(ActionFn(37));)
    //
    pub fn __state369<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<SymbolKind>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action37(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 370
    //   (<Symbol> ",")* = (*) ["("]
    //   (<Symbol> ",")* = (*) ["<"]
    //   (<Symbol> ",")* = (*) [">"]
    //   (<Symbol> ",")* = (*) ["@L"]
    //   (<Symbol> ",")* = (*) ["@R"]
    //   (<Symbol> ",")* = (*) ["Escape"]
    //   (<Symbol> ",")* = (*) ["Id"]
    //   (<Symbol> ",")* = (*) ["MacroId"]
    //   (<Symbol> ",")* = (*) ["StringLiteral"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["("]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["<"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") [">"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["@L"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["@R"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["Escape"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["Id"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["MacroId"]
    //   (<Symbol> ",")* = (*) (<Symbol> ",")* (<Symbol> ",") ["StringLiteral"]
    //   Comma<Symbol> = (*) (<Symbol> ",")* Symbol? [">"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" [","]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" [">"]
    //   SymbolKind1 = MacroId "<" (*) Comma<Symbol> ">" ["?"]
    //
    //   "StringLiteral" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   ">" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "MacroId" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "(" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "@L" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "Id" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "@R" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "Escape" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //   "<" -> Reduce((<Symbol> ",")* =  => Call(ActionFn(138));)
    //
    //   (<Symbol> ",")* -> S261
    //   Comma<Symbol> -> S384
    pub fn __state370<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action138(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cSymbol_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state261(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Comma_3cSymbol_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state384(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 371
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["*"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["+"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" [","]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" [">"]
    //   SymbolKind1 = "(" ExprSymbol (*) ")" ["?"]
    //
    //   ")" -> Shift(S385)
    //
    pub fn __state371<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<ExprSymbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state385(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 372
    //   RepeatOp = (*) "*" ["*"]
    //   RepeatOp = (*) "*" ["+"]
    //   RepeatOp = (*) "*" [">"]
    //   RepeatOp = (*) "*" ["?"]
    //   RepeatOp = (*) "+" ["*"]
    //   RepeatOp = (*) "+" ["+"]
    //   RepeatOp = (*) "+" [">"]
    //   RepeatOp = (*) "+" ["?"]
    //   RepeatOp = (*) "?" ["*"]
    //   RepeatOp = (*) "?" ["+"]
    //   RepeatOp = (*) "?" [">"]
    //   RepeatOp = (*) "?" ["?"]
    //   Symbol = @L "<" Symbol0 (*) ">" @R [","]
    //   Symbol = @L "<" Symbol0 (*) ">" @R [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["*"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["+"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["?"]
    //
    //   ">" -> Shift(S386)
    //   "?" -> Shift(S259)
    //   "*" -> Shift(S257)
    //   "+" -> Shift(S260)
    //
    //   RepeatOp -> S256
    pub fn __state372<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state386(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            Some((_, __tok @ Tok::Question(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state259(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Star(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state257(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Plus(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state260(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::RepeatOp(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state256(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 373
    //   Escape = (*) "Escape" ["*"]
    //   Escape = (*) "Escape" ["+"]
    //   Escape = (*) "Escape" [">"]
    //   Escape = (*) "Escape" ["?"]
    //   Id = (*) "Id" ["*"]
    //   Id = (*) "Id" ["+"]
    //   Id = (*) "Id" [":"]
    //   Id = (*) "Id" [">"]
    //   Id = (*) "Id" ["?"]
    //   MacroId = (*) "MacroId" ["<"]
    //   NonterminalId = (*) Id ["*"]
    //   NonterminalId = (*) Id ["+"]
    //   NonterminalId = (*) Id [">"]
    //   NonterminalId = (*) Id ["?"]
    //   StringLiteral = (*) "StringLiteral" ["*"]
    //   StringLiteral = (*) "StringLiteral" ["+"]
    //   StringLiteral = (*) "StringLiteral" [">"]
    //   StringLiteral = (*) "StringLiteral" ["?"]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R [","]
    //   Symbol = @L "<" @L (*) Id ":" Symbol0 ">" @R [">"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["*"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["+"]
    //   Symbol1 = @L (*) SymbolKind1 @R [">"]
    //   Symbol1 = @L (*) SymbolKind1 @R ["?"]
    //   SymbolKind1 = (*) Escape ["*"]
    //   SymbolKind1 = (*) Escape ["+"]
    //   SymbolKind1 = (*) Escape [">"]
    //   SymbolKind1 = (*) Escape ["?"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["*"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["+"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" [">"]
    //   SymbolKind1 = (*) MacroId "<" Comma<Symbol> ">" ["?"]
    //   SymbolKind1 = (*) NonterminalId ["*"]
    //   SymbolKind1 = (*) NonterminalId ["+"]
    //   SymbolKind1 = (*) NonterminalId [">"]
    //   SymbolKind1 = (*) NonterminalId ["?"]
    //   SymbolKind1 = (*) Terminal ["*"]
    //   SymbolKind1 = (*) Terminal ["+"]
    //   SymbolKind1 = (*) Terminal [">"]
    //   SymbolKind1 = (*) Terminal ["?"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["*"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["+"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" [">"]
    //   SymbolKind1 = (*) "(" ExprSymbol ")" ["?"]
    //   SymbolKind1 = (*) "@L" ["*"]
    //   SymbolKind1 = (*) "@L" ["+"]
    //   SymbolKind1 = (*) "@L" [">"]
    //   SymbolKind1 = (*) "@L" ["?"]
    //   SymbolKind1 = (*) "@R" ["*"]
    //   SymbolKind1 = (*) "@R" ["+"]
    //   SymbolKind1 = (*) "@R" [">"]
    //   SymbolKind1 = (*) "@R" ["?"]
    //   Terminal = (*) StringLiteral ["*"]
    //   Terminal = (*) StringLiteral ["+"]
    //   Terminal = (*) StringLiteral [">"]
    //   Terminal = (*) StringLiteral ["?"]
    //
    //   "@L" -> Shift(S246)
    //   "@R" -> Shift(S255)
    //   "MacroId" -> Shift(S68)
    //   "StringLiteral" -> Shift(S244)
    //   "(" -> Shift(S248)
    //   "Escape" -> Shift(S250)
    //   "Id" -> Shift(S249)
    //
    //   Terminal -> S243
    //   Escape -> S252
    //   StringLiteral -> S253
    //   SymbolKind1 -> S251
    //   MacroId -> S245
    //   Id -> S387
    //   NonterminalId -> S254
    pub fn __state373<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Lookahead(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state246(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Lookbehind(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state255(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::MacroId(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::StringLiteral(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state244(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state248(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state250(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state249(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Terminal(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state243(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state252(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::StringLiteral(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state253(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::SymbolKind1(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state251(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
                }
                __Nonterminal::MacroId(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state245(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state387(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::NonterminalId(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state254(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 374
    //   @R = (*) [","]
    //   @R = (*) ["}"]
    //   Conversion = @L Terminal "=>" (*) @R [","]
    //   Conversion = @L Terminal "=>" (*) @R ["}"]
    //
    //   "}" -> Reduce(@R =  => Lookbehind;)
    //   "," -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S388
    pub fn __state374<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<TerminalString>,
        __sym2: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state388(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 375
    //   AssociatedType* = AssociatedType* AssociatedType (*) ["type"]
    //   AssociatedType* = AssociatedType* AssociatedType (*) ["}"]
    //
    //   "type" -> Reduce(AssociatedType* = AssociatedType*, AssociatedType => Call(ActionFn(81));)
    //   "}" -> Reduce(AssociatedType* = AssociatedType*, AssociatedType => Call(ActionFn(81));)
    //
    pub fn __state375<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym1: &mut Option<AssociatedType>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Type(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action81(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::AssociatedType_2a(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action81(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::AssociatedType_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 376
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" (*) [EOF]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" (*) ["Escape"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" (*) ["Id"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" (*) ["MacroId"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" (*) ["extern"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" (*) ["pub"]
    //   ExternToken = @L "extern" "token" @R "{" AssociatedType* "enum" @L TypeRef @R "{" Comma<Conversion> "}" AssociatedType* "}" (*) ["use"]
    //
    //   "Escape" -> Reduce(ExternToken = @L, "extern", "token", @R, "{", AssociatedType*, "enum", @L, TypeRef, @R, "{", Comma<Conversion>, "}", AssociatedType*, "}" => Call(ActionFn(53));)
    //   "use" -> Reduce(ExternToken = @L, "extern", "token", @R, "{", AssociatedType*, "enum", @L, TypeRef, @R, "{", Comma<Conversion>, "}", AssociatedType*, "}" => Call(ActionFn(53));)
    //   EOF -> Reduce(ExternToken = @L, "extern", "token", @R, "{", AssociatedType*, "enum", @L, TypeRef, @R, "{", Comma<Conversion>, "}", AssociatedType*, "}" => Call(ActionFn(53));)
    //   "Id" -> Reduce(ExternToken = @L, "extern", "token", @R, "{", AssociatedType*, "enum", @L, TypeRef, @R, "{", Comma<Conversion>, "}", AssociatedType*, "}" => Call(ActionFn(53));)
    //   "MacroId" -> Reduce(ExternToken = @L, "extern", "token", @R, "{", AssociatedType*, "enum", @L, TypeRef, @R, "{", Comma<Conversion>, "}", AssociatedType*, "}" => Call(ActionFn(53));)
    //   "extern" -> Reduce(ExternToken = @L, "extern", "token", @R, "{", AssociatedType*, "enum", @L, TypeRef, @R, "{", Comma<Conversion>, "}", AssociatedType*, "}" => Call(ActionFn(53));)
    //   "pub" -> Reduce(ExternToken = @L, "extern", "token", @R, "{", AssociatedType*, "enum", @L, TypeRef, @R, "{", Comma<Conversion>, "}", AssociatedType*, "}" => Call(ActionFn(53));)
    //
    pub fn __state376<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Tok<'input>>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
        __sym8: &mut Option<TypeRef>,
        __sym9: &mut Option<usize>,
        __sym10: &mut Option<Tok<'input>>,
        __sym11: &mut Option<Vec<Conversion>>,
        __sym12: &mut Option<Tok<'input>>,
        __sym13: &mut Option<::std::vec::Vec<AssociatedType>>,
        __sym14: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __sym8 = __sym8.take().unwrap();
                let __sym9 = __sym9.take().unwrap();
                let __sym10 = __sym10.take().unwrap();
                let __sym11 = __sym11.take().unwrap();
                let __sym12 = __sym12.take().unwrap();
                let __sym13 = __sym13.take().unwrap();
                let __sym14 = __sym14.take().unwrap();
                let __nt = super::__action53(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12, __sym13, __sym14);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExternToken(__nt)));
            }
            Some((_, Tok::Use(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __sym8 = __sym8.take().unwrap();
                let __sym9 = __sym9.take().unwrap();
                let __sym10 = __sym10.take().unwrap();
                let __sym11 = __sym11.take().unwrap();
                let __sym12 = __sym12.take().unwrap();
                let __sym13 = __sym13.take().unwrap();
                let __sym14 = __sym14.take().unwrap();
                let __nt = super::__action53(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12, __sym13, __sym14);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExternToken(__nt)));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __sym8 = __sym8.take().unwrap();
                let __sym9 = __sym9.take().unwrap();
                let __sym10 = __sym10.take().unwrap();
                let __sym11 = __sym11.take().unwrap();
                let __sym12 = __sym12.take().unwrap();
                let __sym13 = __sym13.take().unwrap();
                let __sym14 = __sym14.take().unwrap();
                let __nt = super::__action53(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12, __sym13, __sym14);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExternToken(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __sym8 = __sym8.take().unwrap();
                let __sym9 = __sym9.take().unwrap();
                let __sym10 = __sym10.take().unwrap();
                let __sym11 = __sym11.take().unwrap();
                let __sym12 = __sym12.take().unwrap();
                let __sym13 = __sym13.take().unwrap();
                let __sym14 = __sym14.take().unwrap();
                let __nt = super::__action53(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12, __sym13, __sym14);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExternToken(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __sym8 = __sym8.take().unwrap();
                let __sym9 = __sym9.take().unwrap();
                let __sym10 = __sym10.take().unwrap();
                let __sym11 = __sym11.take().unwrap();
                let __sym12 = __sym12.take().unwrap();
                let __sym13 = __sym13.take().unwrap();
                let __sym14 = __sym14.take().unwrap();
                let __nt = super::__action53(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12, __sym13, __sym14);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExternToken(__nt)));
            }
            Some((_, Tok::Extern(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __sym8 = __sym8.take().unwrap();
                let __sym9 = __sym9.take().unwrap();
                let __sym10 = __sym10.take().unwrap();
                let __sym11 = __sym11.take().unwrap();
                let __sym12 = __sym12.take().unwrap();
                let __sym13 = __sym13.take().unwrap();
                let __sym14 = __sym14.take().unwrap();
                let __nt = super::__action53(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12, __sym13, __sym14);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExternToken(__nt)));
            }
            Some((_, Tok::Pub(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __sym8 = __sym8.take().unwrap();
                let __sym9 = __sym9.take().unwrap();
                let __sym10 = __sym10.take().unwrap();
                let __sym11 = __sym11.take().unwrap();
                let __sym12 = __sym12.take().unwrap();
                let __sym13 = __sym13.take().unwrap();
                let __sym14 = __sym14.take().unwrap();
                let __nt = super::__action53(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7, __sym8, __sym9, __sym10, __sym11, __sym12, __sym13, __sym14);
                return Ok((__lookbehind, __lookahead, __Nonterminal::ExternToken(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 377
    //   @L = (*) ["Id"]
    //   AssociatedType = "type" (*) @L Id @R "=" TypeRef ";" ["type"]
    //   AssociatedType = "type" (*) @L Id @R "=" TypeRef ";" ["}"]
    //
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //
    //   @L -> S389
    pub fn __state377<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state389(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 378
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [";"]
    //
    //   ";" -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //
    pub fn __state378<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym3: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 379
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [";"]
    //
    //   ";" -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //
    pub fn __state379<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 380
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["("]
    //   Symbol = @L "<" Symbol0 ">" @R (*) [")"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["<"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["@L"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["@R"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["Escape"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["Id"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["MacroId"]
    //   Symbol = @L "<" Symbol0 ">" @R (*) ["StringLiteral"]
    //
    //   "Escape" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   ")" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "@L" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "MacroId" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "(" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "<" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "@R" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "Id" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   "StringLiteral" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //
    pub fn __state380<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Symbol>,
        __sym3: &mut Option<Tok<'input>>,
        __sym4: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 381
    //   @L = (*) ["("]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["("]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R [")"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["<"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["@L"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["@R"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["Escape"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["Id"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["MacroId"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R ["StringLiteral"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["*"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["+"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["?"]
    //   Symbol0 = (*) Symbol1 ["*"]
    //   Symbol0 = (*) Symbol1 ["+"]
    //   Symbol0 = (*) Symbol1 [">"]
    //   Symbol0 = (*) Symbol1 ["?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["*"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["+"]
    //   Symbol1 = (*) @L SymbolKind1 @R [">"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["?"]
    //
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //
    //   Symbol0 -> S390
    //   @L -> S327
    //   Symbol1 -> S220
    pub fn __state381<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym4.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol0(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state390(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state327(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                __Nonterminal::Symbol1(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state220(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 382
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["("]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) [")"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["*"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["+"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["<"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["?"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["@L"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["@R"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["Escape"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["Id"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["MacroId"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["StringLiteral"]
    //
    //   "StringLiteral" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "(" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "MacroId" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "<" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "?" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "Escape" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "+" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "*" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "@L" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "Id" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "@R" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   ")" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //
    pub fn __state382<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Symbol>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 383
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["("]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) [";"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["<"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["=>"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["=>?"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["=>@L"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["=>@R"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["@L"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["@R"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["Escape"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["Id"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["MacroId"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["StringLiteral"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["if"]
    //
    //   ";" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "Escape" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "if" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "(" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "MacroId" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "=>@L" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "@R" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "@L" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "Id" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "StringLiteral" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "<" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "=>" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "=>@R" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "=>?" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //
    pub fn __state383<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<Symbol>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Semi(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::If(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanLookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::EqualsGreaterThanQuestionCode(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 384
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["*"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["+"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" [","]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" [">"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> (*) ">" ["?"]
    //
    //   ">" -> Shift(S391)
    //
    pub fn __state384<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Symbol>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state391(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 385
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["*"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["+"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) [","]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) [">"]
    //   SymbolKind1 = "(" ExprSymbol ")" (*) ["?"]
    //
    //   "," -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "*" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "+" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   "?" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //   ">" -> Reduce(SymbolKind1 = "(", ExprSymbol, ")" => Call(ActionFn(42));)
    //
    pub fn __state385<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<ExprSymbol>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action42(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 386
    //   @R = (*) [","]
    //   @R = (*) [">"]
    //   Symbol = @L "<" Symbol0 ">" (*) @R [","]
    //   Symbol = @L "<" Symbol0 ">" (*) @R [">"]
    //
    //   "," -> Reduce(@R =  => Lookbehind;)
    //   ">" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S392
    pub fn __state386<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Symbol>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym3.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state392(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 387
    //   NonterminalId = Id (*) ["*"]
    //   NonterminalId = Id (*) ["+"]
    //   NonterminalId = Id (*) [">"]
    //   NonterminalId = Id (*) ["?"]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R [","]
    //   Symbol = @L "<" @L Id (*) ":" Symbol0 ">" @R [">"]
    //
    //   "?" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   "*" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   ">" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //   ":" -> Shift(S393)
    //   "+" -> Reduce(NonterminalId = Id => Call(ActionFn(67));)
    //
    pub fn __state387<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Colon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state393(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Star(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action67(text, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::NonterminalId(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 388
    //   Conversion = @L Terminal "=>" @R (*) [","]
    //   Conversion = @L Terminal "=>" @R (*) ["}"]
    //
    //   "}" -> Reduce(Conversion = @L, Terminal, "=>", @R => TryCall(ActionFn(55));)
    //   "," -> Reduce(Conversion = @L, Terminal, "=>", @R => TryCall(ActionFn(55));)
    //
    pub fn __state388<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<TerminalString>,
        __sym2: &mut Option<&'input str>,
        __sym3: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = try!(super::__action55(text, __sym0, __sym1, __sym2, __sym3));
                return Ok((__lookbehind, __lookahead, __Nonterminal::Conversion(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = try!(super::__action55(text, __sym0, __sym1, __sym2, __sym3));
                return Ok((__lookbehind, __lookahead, __Nonterminal::Conversion(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 389
    //   AssociatedType = "type" @L (*) Id @R "=" TypeRef ";" ["type"]
    //   AssociatedType = "type" @L (*) Id @R "=" TypeRef ";" ["}"]
    //   Id = (*) "Id" ["="]
    //
    //   "Id" -> Shift(S176)
    //
    //   Id -> S394
    pub fn __state389<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state176(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state394(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 390
    //   RepeatOp = (*) "*" ["*"]
    //   RepeatOp = (*) "*" ["+"]
    //   RepeatOp = (*) "*" [">"]
    //   RepeatOp = (*) "*" ["?"]
    //   RepeatOp = (*) "+" ["*"]
    //   RepeatOp = (*) "+" ["+"]
    //   RepeatOp = (*) "+" [">"]
    //   RepeatOp = (*) "+" ["?"]
    //   RepeatOp = (*) "?" ["*"]
    //   RepeatOp = (*) "?" ["+"]
    //   RepeatOp = (*) "?" [">"]
    //   RepeatOp = (*) "?" ["?"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["("]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R [")"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["<"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["@L"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["@R"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["Escape"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["Id"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["MacroId"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R ["StringLiteral"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["*"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["+"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["?"]
    //
    //   "*" -> Shift(S257)
    //   "?" -> Shift(S259)
    //   "+" -> Shift(S260)
    //   ">" -> Shift(S395)
    //
    //   RepeatOp -> S256
    pub fn __state390<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Star(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state257(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, __tok @ Tok::Question(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state259(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, __tok @ Tok::Plus(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state260(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state395(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym5.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::RepeatOp(__nt) => {
                    let __sym6 = &mut Some(__nt);
                    __result = try!(__state256(text, __lookbehind, __lookahead, __tokens, __sym5, __sym6));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 391
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["*"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["+"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) [","]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) [">"]
    //   SymbolKind1 = MacroId "<" Comma<Symbol> ">" (*) ["?"]
    //
    //   "*" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "?" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "," -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   ">" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //   "+" -> Reduce(SymbolKind1 = MacroId, "<", Comma<Symbol>, ">" => Call(ActionFn(38));)
    //
    pub fn __state391<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<NonterminalString>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Symbol>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Star(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Question(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            Some((_, Tok::Plus(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action38(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::SymbolKind1(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 392
    //   Symbol = @L "<" Symbol0 ">" @R (*) [","]
    //   Symbol = @L "<" Symbol0 ">" @R (*) [">"]
    //
    //   "," -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //   ">" -> Reduce(Symbol = @L, "<", Symbol0, ">", @R => Call(ActionFn(30));)
    //
    pub fn __state392<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Symbol>,
        __sym3: &mut Option<Tok<'input>>,
        __sym4: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action30(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 393
    //   @L = (*) ["("]
    //   @L = (*) ["@L"]
    //   @L = (*) ["@R"]
    //   @L = (*) ["Escape"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["MacroId"]
    //   @L = (*) ["StringLiteral"]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R [","]
    //   Symbol = @L "<" @L Id ":" (*) Symbol0 ">" @R [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["*"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["+"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R [">"]
    //   Symbol0 = (*) Symbol0 RepeatOp @R ["?"]
    //   Symbol0 = (*) Symbol1 ["*"]
    //   Symbol0 = (*) Symbol1 ["+"]
    //   Symbol0 = (*) Symbol1 [">"]
    //   Symbol0 = (*) Symbol1 ["?"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["*"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["+"]
    //   Symbol1 = (*) @L SymbolKind1 @R [">"]
    //   Symbol1 = (*) @L SymbolKind1 @R ["?"]
    //
    //   "Escape" -> Reduce(@L =  => Lookahead;)
    //   "@R" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "StringLiteral" -> Reduce(@L =  => Lookahead;)
    //   "MacroId" -> Reduce(@L =  => Lookahead;)
    //   "@L" -> Reduce(@L =  => Lookahead;)
    //
    //   Symbol1 -> S220
    //   Symbol0 -> S396
    //   @L -> S327
    pub fn __state393<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym4.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Symbol1(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state220(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                __Nonterminal::Symbol0(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state396(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state327(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 394
    //   @R = (*) ["="]
    //   AssociatedType = "type" @L Id (*) @R "=" TypeRef ";" ["type"]
    //   AssociatedType = "type" @L Id (*) @R "=" TypeRef ";" ["}"]
    //
    //   "=" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S397
    pub fn __state394<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Equals(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state397(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 395
    //   @R = (*) ["("]
    //   @R = (*) [")"]
    //   @R = (*) ["<"]
    //   @R = (*) ["@L"]
    //   @R = (*) ["@R"]
    //   @R = (*) ["Escape"]
    //   @R = (*) ["Id"]
    //   @R = (*) ["MacroId"]
    //   @R = (*) ["StringLiteral"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["("]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R [")"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["<"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["@L"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["@R"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["Escape"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["Id"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["MacroId"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R ["StringLiteral"]
    //
    //   ")" -> Reduce(@R =  => Lookbehind;)
    //   "StringLiteral" -> Reduce(@R =  => Lookbehind;)
    //   "(" -> Reduce(@R =  => Lookbehind;)
    //   "Id" -> Reduce(@R =  => Lookbehind;)
    //   "MacroId" -> Reduce(@R =  => Lookbehind;)
    //   "Escape" -> Reduce(@R =  => Lookbehind;)
    //   "@R" -> Reduce(@R =  => Lookbehind;)
    //   "<" -> Reduce(@R =  => Lookbehind;)
    //   "@L" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S398
    pub fn __state395<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<Symbol>,
        __sym6: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym6.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym7 = &mut Some(__nt);
                    __result = try!(__state398(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 396
    //   RepeatOp = (*) "*" ["*"]
    //   RepeatOp = (*) "*" ["+"]
    //   RepeatOp = (*) "*" [">"]
    //   RepeatOp = (*) "*" ["?"]
    //   RepeatOp = (*) "+" ["*"]
    //   RepeatOp = (*) "+" ["+"]
    //   RepeatOp = (*) "+" [">"]
    //   RepeatOp = (*) "+" ["?"]
    //   RepeatOp = (*) "?" ["*"]
    //   RepeatOp = (*) "?" ["+"]
    //   RepeatOp = (*) "?" [">"]
    //   RepeatOp = (*) "?" ["?"]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R [","]
    //   Symbol = @L "<" @L Id ":" Symbol0 (*) ">" @R [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["*"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["+"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R [">"]
    //   Symbol0 = Symbol0 (*) RepeatOp @R ["?"]
    //
    //   "?" -> Shift(S259)
    //   ">" -> Shift(S399)
    //   "+" -> Shift(S260)
    //   "*" -> Shift(S257)
    //
    //   RepeatOp -> S256
    pub fn __state396<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<Symbol>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Question(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state259(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state399(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6));
            }
            Some((_, __tok @ Tok::Plus(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state260(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            Some((_, __tok @ Tok::Star(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state257(text, __lookbehind, __lookahead, __tokens, __sym6));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym5.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::RepeatOp(__nt) => {
                    let __sym6 = &mut Some(__nt);
                    __result = try!(__state256(text, __lookbehind, __lookahead, __tokens, __sym5, __sym6));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 397
    //   AssociatedType = "type" @L Id @R (*) "=" TypeRef ";" ["type"]
    //   AssociatedType = "type" @L Id @R (*) "=" TypeRef ";" ["}"]
    //
    //   "=" -> Shift(S400)
    //
    pub fn __state397<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
        __sym3: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Equals(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state400(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 398
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["("]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) [")"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["<"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["@L"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["@R"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["Escape"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["Id"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["MacroId"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) ["StringLiteral"]
    //
    //   "Id" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "MacroId" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "Escape" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "StringLiteral" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "<" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "@L" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "@R" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   ")" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   "(" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //
    pub fn __state398<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<Symbol>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::MacroId(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::StringLiteral(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookahead(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::Lookbehind(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 399
    //   @R = (*) [","]
    //   @R = (*) [">"]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R [","]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" (*) @R [">"]
    //
    //   ">" -> Reduce(@R =  => Lookbehind;)
    //   "," -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S401
    pub fn __state399<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<Symbol>,
        __sym6: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym6.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym7 = &mut Some(__nt);
                    __result = try!(__state401(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 400
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   AssociatedType = "type" @L Id @R "=" (*) TypeRef ";" ["type"]
    //   AssociatedType = "type" @L Id @R "=" (*) TypeRef ";" ["}"]
    //   Escape = (*) "Escape" [";"]
    //   Path = (*) "::"? (<Id> "::")* Id [";"]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   TypeRef = (*) Escape [";"]
    //   TypeRef = (*) Path [";"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [";"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [";"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [";"]
    //
    //   "Escape" -> Shift(S268)
    //   "&" -> Shift(S273)
    //   "(" -> Shift(S270)
    //   "::" -> Shift(S50)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //
    //   Path -> S274
    //   Escape -> S271
    //   TypeRef -> S402
    //   "::"? -> S272
    pub fn __state400<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state268(text, __lookbehind, __lookahead, __tokens, __sym5));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state273(text, __lookbehind, __lookahead, __tokens, __sym5));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state270(text, __lookbehind, __lookahead, __tokens, __sym5));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym5 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym5));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym4.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Path(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state274(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state271(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state402(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym5 = &mut Some(__nt);
                    __result = try!(__state272(text, __lookbehind, __lookahead, __tokens, __sym5));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 401
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) [","]
    //   Symbol = @L "<" @L Id ":" Symbol0 ">" @R (*) [">"]
    //
    //   "," -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //   ">" -> Reduce(Symbol = @L, "<", @L, Id, ":", Symbol0, ">", @R => Call(ActionFn(29));)
    //
    pub fn __state401<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<InternedString>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<Symbol>,
        __sym6: &mut Option<Tok<'input>>,
        __sym7: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __sym7 = __sym7.take().unwrap();
                let __nt = super::__action29(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6, __sym7);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Symbol(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 402
    //   AssociatedType = "type" @L Id @R "=" TypeRef (*) ";" ["type"]
    //   AssociatedType = "type" @L Id @R "=" TypeRef (*) ";" ["}"]
    //
    //   ";" -> Shift(S403)
    //
    pub fn __state402<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Semi(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym6 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state403(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 403
    //   AssociatedType = "type" @L Id @R "=" TypeRef ";" (*) ["type"]
    //   AssociatedType = "type" @L Id @R "=" TypeRef ";" (*) ["}"]
    //
    //   "}" -> Reduce(AssociatedType = "type", @L, Id, @R, "=", TypeRef, ";" => Call(ActionFn(54));)
    //   "type" -> Reduce(AssociatedType = "type", @L, Id, @R, "=", TypeRef, ";" => Call(ActionFn(54));)
    //
    pub fn __state403<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<usize>,
        __sym2: &mut Option<InternedString>,
        __sym3: &mut Option<usize>,
        __sym4: &mut Option<Tok<'input>>,
        __sym5: &mut Option<TypeRef>,
        __sym6: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action54(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::AssociatedType(__nt)));
            }
            Some((_, Tok::Type(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __sym5 = __sym5.take().unwrap();
                let __sym6 = __sym6.take().unwrap();
                let __nt = super::__action54(text, __sym0, __sym1, __sym2, __sym3, __sym4, __sym5, __sym6);
                return Ok((__lookbehind, __lookahead, __Nonterminal::AssociatedType(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }
}
#[allow(non_snake_case)]
pub fn parse_Pattern<
    'input,
    __TOKEN: __ToTriple<'input, Error=tok::Error>,
    __TOKENS: IntoIterator<Item=__TOKEN>,
>(
    text: &'input str,
    __tokens: __TOKENS,
) -> Result<Pattern<TypeRef>, __ParseError<usize,Tok<'input>,tok::Error>>
{
    let mut __tokens = __tokens.into_iter();
    let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t));
    let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
    match try!(__parse__Pattern::__state0(text, None, __lookahead, &mut __tokens)) {
        (_, Some(__lookahead), _) => {
            Err(__ParseError::ExtraToken { token: __lookahead })
        }
        (_, None, __parse__Pattern::__Nonterminal::____Pattern(__nt)) => {
            Ok(__nt)
        }
        _ => unreachable!(),
    }
}

mod __parse__Pattern {
    #![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports)]

    use intern::{intern, InternedString};
    use grammar::parse_tree::*;
    use grammar::pattern::*;
    use std::iter::once;
    use tok::{self, Tok};
    extern crate lalrpop_util as __lalrpop_util;
    use self::__lalrpop_util::ParseError as __ParseError;
    use super::__ToTriple;

    pub enum __Nonterminal<'input, > {
        ____Grammar(Grammar),
        Comma_3cNonterminalId_3e(Vec<NonterminalString>),
        _28_3cNonterminalId_3e_20_22_2c_22_29_2a(::std::vec::Vec<NonterminalString>),
        AssociatedType(AssociatedType),
        Action_3f(::std::option::Option<ActionKind>),
        GrammarParameter_3f(::std::option::Option<Parameter>),
        NonterminalId_3f(::std::option::Option<NonterminalString>),
        Alternatives(Vec<Alternative>),
        _28_3cId_3e_20_22_3a_3a_22_29_2a(::std::vec::Vec<InternedString>),
        _28_3cFieldPattern_3e_20_22_2c_22_29(FieldPattern<TypeRef>),
        _22where_22_3f(::std::option::Option<Vec<&'input str>>),
        Id(InternedString),
        _28_3cTypeRef_3e_20_22_2c_22_29(TypeRef),
        _40R(usize),
        GrammarTypeParameters_3f(::std::option::Option<Vec<TypeParameter>>),
        Use_2a(::std::vec::Vec<GrammarItem>),
        _28_3cConversion_3e_20_22_2c_22_29(Conversion),
        Symbol1(Symbol),
        GrammarItem(GrammarItem),
        RepeatOp(RepeatOp),
        ExprSymbol(ExprSymbol),
        Terminal(TerminalString),
        Symbol_3f(::std::option::Option<Symbol>),
        MacroId(NonterminalString),
        _28_22if_22_20_3cCond_3e_29(Condition),
        GrammarItem_2a(::std::vec::Vec<GrammarItem>),
        FieldPattern_3f(::std::option::Option<FieldPattern<TypeRef>>),
        _28_3cTypeRef_3e_20_22_2c_22_29_2a(::std::vec::Vec<TypeRef>),
        Comma_3cConversion_3e(Vec<Conversion>),
        Action(ActionKind),
        Cond(Condition),
        Conversion_3f(::std::option::Option<Conversion>),
        _28_3cFieldPattern_3e_20_22_2c_22_29_2a(::std::vec::Vec<FieldPattern<TypeRef>>),
        GrammarParameters(Vec<Parameter>),
        _22_3a_3a_22_3f(::std::option::Option<Tok<'input>>),
        TypeRefOrLifetime_3f(::std::option::Option<TypeRef>),
        _28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(::std::vec::Vec<TypeRef>),
        AssociatedType_2a(::std::vec::Vec<AssociatedType>),
        NonterminalName((NonterminalString, Vec<NonterminalString>)),
        Comma_3cTypeRefOrLifetime_3e(Vec<TypeRef>),
        FieldPattern(FieldPattern<TypeRef>),
        Escape(InternedString),
        Symbol0(Symbol),
        Pattern_3f(::std::option::Option<Pattern<TypeRef>>),
        _28_22if_22_20_3cCond_3e_29_3f(::std::option::Option<Condition>),
        _28_3cTypeParameter_3e_20_22_2c_22_29_2a(::std::vec::Vec<TypeParameter>),
        SymbolKind1(SymbolKind),
        Symbol(Symbol),
        Alternative(Alternative),
        _22mut_22_3f(::std::option::Option<Tok<'input>>),
        PatternKind(PatternKind<TypeRef>),
        GrammarTypeParameters(Vec<TypeParameter>),
        Path(Path),
        TypeRef_3f(::std::option::Option<TypeRef>),
        ExternToken(GrammarItem),
        Lifetime_3f(::std::option::Option<InternedString>),
        Comma_3cTypeRef_3e(Vec<TypeRef>),
        Comma_3cGrammarParameter_3e(Vec<Parameter>),
        Grammar(Grammar),
        _28_3cPattern_3e_20_22_2c_22_29_2a(::std::vec::Vec<Pattern<TypeRef>>),
        GrammarParameter(Parameter),
        _28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(TypeRef),
        _28_3cGrammarParameter_3e_20_22_2c_22_29(Parameter),
        _28_3cSymbol_3e_20_22_2c_22_29_2a(::std::vec::Vec<Symbol>),
        TypeRef(TypeRef),
        _28_22_3a_22_20_3cTypeRef_3e_29_3f(::std::option::Option<TypeRef>),
        Nonterminal(GrammarItem),
        Pattern(Pattern<TypeRef>),
        Conversion(Conversion),
        Use(GrammarItem),
        CondOp(ConditionOp),
        NonterminalId(NonterminalString),
        Comma_3cSymbol_3e(Vec<Symbol>),
        _28_3cSymbol_3e_20_22_2c_22_29(Symbol),
        _28_22_3a_22_20_3cTypeRef_3e_29(TypeRef),
        _28_3cId_3e_20_22_3a_3a_22_29(InternedString),
        Alternative_2a(::std::vec::Vec<Alternative>),
        _28_3cGrammarParameter_3e_20_22_2c_22_29_2a(::std::vec::Vec<Parameter>),
        _40L(usize),
        _28_3cTypeParameter_3e_20_22_2c_22_29(TypeParameter),
        Lifetime(InternedString),
        TypeParameter_3f(::std::option::Option<TypeParameter>),
        _28_3cConversion_3e_20_22_2c_22_29_2a(::std::vec::Vec<Conversion>),
        TypeParameter(TypeParameter),
        Comma_3cTypeParameter_3e(Vec<TypeParameter>),
        _28_3cNonterminalId_3e_20_22_2c_22_29(NonterminalString),
        _22pub_22_3f(::std::option::Option<Tok<'input>>),
        Comma_3cPattern_3e(Vec<Pattern<TypeRef>>),
        TypeRefOrLifetime(TypeRef),
        _28_3cPattern_3e_20_22_2c_22_29(Pattern<TypeRef>),
        GrammarParameters_3f(::std::option::Option<Vec<Parameter>>),
        Symbol_2a(::std::vec::Vec<Symbol>),
        ____Pattern(Pattern<TypeRef>),
        StringLiteral(InternedString),
    }

    // State 0
    //   @L = (*) ["("]
    //   @L = (*) [".."]
    //   @L = (*) ["::"]
    //   @L = (*) ["<"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["_"]
    //   Pattern = (*) @L PatternKind @R [EOF]
    //   __Pattern = (*) Pattern [EOF]
    //
    //   "_" -> Reduce(@L =  => Lookahead;)
    //   "<" -> Reduce(@L =  => Lookahead;)
    //   "::" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   ".." -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //
    //   @L -> S2
    //   Pattern -> S1
    pub fn __state0<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Underscore(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        loop {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym0 = &mut Some(__nt);
                    __result = try!(__state2(text, __lookbehind, __lookahead, __tokens, __sym0));
                }
                __Nonterminal::Pattern(__nt) => {
                    let __sym0 = &mut Some(__nt);
                    __result = try!(__state1(text, __lookbehind, __lookahead, __tokens, __sym0));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
    }

    // State 1
    //   __Pattern = Pattern (*) [EOF]
    //
    //   EOF -> Reduce(__Pattern = Pattern => Call(ActionFn(1));)
    //
    pub fn __state1<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Pattern<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action1(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::____Pattern(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 2
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Path = (*) "::"? (<Id> "::")* Id [EOF]
    //   Path = (*) "::"? (<Id> "::")* Id ["("]
    //   Path = (*) "::"? (<Id> "::")* Id ["{"]
    //   Pattern = @L (*) PatternKind @R [EOF]
    //   PatternKind = (*) Path [EOF]
    //   PatternKind = (*) Path "(" Comma<Pattern> ")" [EOF]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* FieldPattern? "}" [EOF]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* ".." "}" [EOF]
    //   PatternKind = (*) "(" Comma<Pattern> ")" [EOF]
    //   PatternKind = (*) ".." [EOF]
    //   PatternKind = (*) "<" TypeRef ">" [EOF]
    //   PatternKind = (*) "_" [EOF]
    //
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "(" -> Shift(S7)
    //   "::" -> Shift(S6)
    //   "<" -> Shift(S9)
    //   ".." -> Shift(S4)
    //   "_" -> Shift(S8)
    //
    //   PatternKind -> S5
    //   Path -> S3
    //   "::"? -> S10
    pub fn __state2<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state7(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state9(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::DotDot(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state4(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Underscore(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state8(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::PatternKind(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state5(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state3(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state10(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 3
    //   PatternKind = Path (*) [EOF]
    //   PatternKind = Path (*) "(" Comma<Pattern> ")" [EOF]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* FieldPattern? "}" [EOF]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* ".." "}" [EOF]
    //
    //   "(" -> Shift(S12)
    //   EOF -> Reduce(PatternKind = Path => Call(ActionFn(64));)
    //   "{" -> Shift(S11)
    //
    pub fn __state3<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state12(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, __tok @ Tok::LeftBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state11(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action64(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 4
    //   PatternKind = ".." (*) [EOF]
    //
    //   EOF -> Reduce(PatternKind = ".." => Call(ActionFn(61));)
    //
    pub fn __state4<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action61(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 5
    //   @R = (*) [EOF]
    //   Pattern = @L PatternKind (*) @R [EOF]
    //
    //   EOF -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S13
    pub fn __state5<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<PatternKind<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state13(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 6
    //   "::"? = "::" (*) ["Id"]
    //
    //   "Id" -> Reduce("::"? = "::" => Call(ActionFn(85));)
    //
    pub fn __state6<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action85(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 7
    //   (<Pattern> ",")* = (*) ["("]
    //   (<Pattern> ",")* = (*) [")"]
    //   (<Pattern> ",")* = (*) [".."]
    //   (<Pattern> ",")* = (*) ["::"]
    //   (<Pattern> ",")* = (*) ["<"]
    //   (<Pattern> ",")* = (*) ["Id"]
    //   (<Pattern> ",")* = (*) ["_"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["("]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [")"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [".."]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["::"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["<"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["Id"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["_"]
    //   Comma<Pattern> = (*) (<Pattern> ",")* Pattern? [")"]
    //   PatternKind = "(" (*) Comma<Pattern> ")" [EOF]
    //
    //   "_" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   ")" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   ".." -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "<" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "::" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "(" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "Id" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //
    //   Comma<Pattern> -> S15
    //   (<Pattern> ",")* -> S14
    pub fn __state7<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Underscore(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cPattern_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state15(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state14(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 8
    //   PatternKind = "_" (*) [EOF]
    //
    //   EOF -> Reduce(PatternKind = "_" => Call(ActionFn(60));)
    //
    pub fn __state8<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action60(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 9
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [">"]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id [">"]
    //   PatternKind = "<" (*) TypeRef ">" [EOF]
    //   TypeRef = (*) Escape [">"]
    //   TypeRef = (*) Path [">"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [">"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [">"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [">"]
    //
    //   "(" -> Shift(S18)
    //   "&" -> Shift(S17)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "::" -> Shift(S6)
    //   "Escape" -> Shift(S22)
    //
    //   "::"? -> S16
    //   Escape -> S20
    //   Path -> S21
    //   TypeRef -> S19
    pub fn __state9<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state18(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state17(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state22(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state16(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state20(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state21(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state19(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 10
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id [EOF]
    //   Path = "::"? (*) (<Id> "::")* Id ["("]
    //   Path = "::"? (*) (<Id> "::")* Id ["{"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S23
    pub fn __state10<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state23(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 11
    //   (<FieldPattern> ",")* = (*) [".."]
    //   (<FieldPattern> ",")* = (*) ["Id"]
    //   (<FieldPattern> ",")* = (*) ["}"]
    //   (<FieldPattern> ",")* = (*) (<FieldPattern> ",")* (<FieldPattern> ",") [".."]
    //   (<FieldPattern> ",")* = (*) (<FieldPattern> ",")* (<FieldPattern> ",") ["Id"]
    //   (<FieldPattern> ",")* = (*) (<FieldPattern> ",")* (<FieldPattern> ",") ["}"]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* FieldPattern? "}" [EOF]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* ".." "}" [EOF]
    //
    //   "Id" -> Reduce((<FieldPattern> ",")* =  => Call(ActionFn(75));)
    //   "}" -> Reduce((<FieldPattern> ",")* =  => Call(ActionFn(75));)
    //   ".." -> Reduce((<FieldPattern> ",")* =  => Call(ActionFn(75));)
    //
    //   (<FieldPattern> ",")* -> S24
    pub fn __state11<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action75(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action75(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = super::__action75(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state24(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 12
    //   (<Pattern> ",")* = (*) ["("]
    //   (<Pattern> ",")* = (*) [")"]
    //   (<Pattern> ",")* = (*) [".."]
    //   (<Pattern> ",")* = (*) ["::"]
    //   (<Pattern> ",")* = (*) ["<"]
    //   (<Pattern> ",")* = (*) ["Id"]
    //   (<Pattern> ",")* = (*) ["_"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["("]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [")"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [".."]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["::"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["<"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["Id"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["_"]
    //   Comma<Pattern> = (*) (<Pattern> ",")* Pattern? [")"]
    //   PatternKind = Path "(" (*) Comma<Pattern> ")" [EOF]
    //
    //   "::" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "<" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   ".." -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "_" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   ")" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "Id" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "(" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //
    //   Comma<Pattern> -> S25
    //   (<Pattern> ",")* -> S14
    pub fn __state12<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Underscore(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cPattern_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state25(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state14(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 13
    //   Pattern = @L PatternKind @R (*) [EOF]
    //
    //   EOF -> Reduce(Pattern = @L, PatternKind, @R => Call(ActionFn(56));)
    //
    pub fn __state13<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<PatternKind<TypeRef>>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action56(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Pattern(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 14
    //   (<Pattern> ",") = (*) Pattern "," ["("]
    //   (<Pattern> ",") = (*) Pattern "," [")"]
    //   (<Pattern> ",") = (*) Pattern "," [".."]
    //   (<Pattern> ",") = (*) Pattern "," ["::"]
    //   (<Pattern> ",") = (*) Pattern "," ["<"]
    //   (<Pattern> ",") = (*) Pattern "," ["Id"]
    //   (<Pattern> ",") = (*) Pattern "," ["_"]
    //   (<Pattern> ",")* = (<Pattern> ",")* (*) (<Pattern> ",") ["("]
    //   (<Pattern> ",")* = (<Pattern> ",")* (*) (<Pattern> ",") [")"]
    //   (<Pattern> ",")* = (<Pattern> ",")* (*) (<Pattern> ",") [".."]
    //   (<Pattern> ",")* = (<Pattern> ",")* (*) (<Pattern> ",") ["::"]
    //   (<Pattern> ",")* = (<Pattern> ",")* (*) (<Pattern> ",") ["<"]
    //   (<Pattern> ",")* = (<Pattern> ",")* (*) (<Pattern> ",") ["Id"]
    //   (<Pattern> ",")* = (<Pattern> ",")* (*) (<Pattern> ",") ["_"]
    //   @L = (*) ["("]
    //   @L = (*) [".."]
    //   @L = (*) ["::"]
    //   @L = (*) ["<"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["_"]
    //   Comma<Pattern> = (<Pattern> ",")* (*) Pattern? [")"]
    //   Pattern = (*) @L PatternKind @R [")"]
    //   Pattern = (*) @L PatternKind @R [","]
    //   Pattern? = (*) [")"]
    //   Pattern? = (*) Pattern [")"]
    //
    //   "::" -> Reduce(@L =  => Lookahead;)
    //   ".." -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   ")" -> Reduce(Pattern? =  => Call(ActionFn(157));)
    //   "_" -> Reduce(@L =  => Lookahead;)
    //   "<" -> Reduce(@L =  => Lookahead;)
    //
    //   (<Pattern> ",") -> S28
    //   Pattern? -> S27
    //   Pattern -> S26
    //   @L -> S29
    pub fn __state14<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Pattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action157(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Pattern_3f(__nt));
            }
            Some((_, Tok::Underscore(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state28(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Pattern_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state27(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Pattern(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state26(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state29(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 15
    //   PatternKind = "(" Comma<Pattern> (*) ")" [EOF]
    //
    //   ")" -> Shift(S30)
    //
    pub fn __state15<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<Pattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state30(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 16
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id ["<"]
    //   Path = "::"? (*) (<Id> "::")* Id [">"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S31
    pub fn __state16<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state31(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 17
    //   Lifetime = (*) "Lifetime" ["&"]
    //   Lifetime = (*) "Lifetime" ["("]
    //   Lifetime = (*) "Lifetime" ["::"]
    //   Lifetime = (*) "Lifetime" ["Escape"]
    //   Lifetime = (*) "Lifetime" ["Id"]
    //   Lifetime = (*) "Lifetime" ["mut"]
    //   Lifetime? = (*) ["&"]
    //   Lifetime? = (*) ["("]
    //   Lifetime? = (*) ["::"]
    //   Lifetime? = (*) ["Escape"]
    //   Lifetime? = (*) ["Id"]
    //   Lifetime? = (*) ["mut"]
    //   Lifetime? = (*) Lifetime ["&"]
    //   Lifetime? = (*) Lifetime ["("]
    //   Lifetime? = (*) Lifetime ["::"]
    //   Lifetime? = (*) Lifetime ["Escape"]
    //   Lifetime? = (*) Lifetime ["Id"]
    //   Lifetime? = (*) Lifetime ["mut"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [">"]
    //
    //   "Lifetime" -> Shift(S32)
    //   "(" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Id" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "mut" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "&" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "::" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Escape" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //
    //   Lifetime -> S33
    //   Lifetime? -> S34
    pub fn __state17<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state32(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state33(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Lifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state34(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 18
    //   (<TypeRef> ",")* = (*) ["&"]
    //   (<TypeRef> ",")* = (*) ["("]
    //   (<TypeRef> ",")* = (*) [")"]
    //   (<TypeRef> ",")* = (*) ["::"]
    //   (<TypeRef> ",")* = (*) ["Escape"]
    //   (<TypeRef> ",")* = (*) ["Id"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (*) (<TypeRef> ",")* TypeRef? [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [">"]
    //
    //   "&" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "(" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Id" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "::" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   ")" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Escape" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //
    //   (<TypeRef> ",")* -> S36
    //   Comma<TypeRef> -> S35
    pub fn __state18<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state36(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Comma_3cTypeRef_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state35(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 19
    //   PatternKind = "<" TypeRef (*) ">" [EOF]
    //
    //   ">" -> Shift(S37)
    //
    pub fn __state19<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state37(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 20
    //   TypeRef = Escape (*) [">"]
    //
    //   ">" -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //
    pub fn __state20<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 21
    //   TypeRef = Path (*) [">"]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [">"]
    //
    //   ">" -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //   "<" -> Shift(S38)
    //
    pub fn __state21<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state38(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 22
    //   Escape = "Escape" (*) [">"]
    //
    //   ">" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state22<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 23
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" [EOF]
    //   Id = (*) "Id" ["("]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["{"]
    //   Path = "::"? (<Id> "::")* (*) Id [EOF]
    //   Path = "::"? (<Id> "::")* (*) Id ["("]
    //   Path = "::"? (<Id> "::")* (*) Id ["{"]
    //
    //   "Id" -> Shift(S39)
    //
    //   Id -> S41
    //   (<Id> "::") -> S40
    pub fn __state23<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state39(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state41(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state40(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 24
    //   (<FieldPattern> ",") = (*) FieldPattern "," [".."]
    //   (<FieldPattern> ",") = (*) FieldPattern "," ["Id"]
    //   (<FieldPattern> ",") = (*) FieldPattern "," ["}"]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (*) (<FieldPattern> ",") [".."]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (*) (<FieldPattern> ",") ["Id"]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (*) (<FieldPattern> ",") ["}"]
    //   @L = (*) ["Id"]
    //   FieldPattern = (*) @L Id @R ":" Pattern [","]
    //   FieldPattern = (*) @L Id @R ":" Pattern ["}"]
    //   FieldPattern? = (*) ["}"]
    //   FieldPattern? = (*) FieldPattern ["}"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) FieldPattern? "}" [EOF]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) ".." "}" [EOF]
    //
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   ".." -> Shift(S43)
    //   "}" -> Reduce(FieldPattern? =  => Call(ActionFn(74));)
    //
    //   @L -> S44
    //   FieldPattern -> S45
    //   (<FieldPattern> ",") -> S46
    //   FieldPattern? -> S42
    pub fn __state24<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::DotDot(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state43(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action74(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::FieldPattern_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state44(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::FieldPattern(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state45(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state46(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
                }
                __Nonterminal::FieldPattern_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state42(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 25
    //   PatternKind = Path "(" Comma<Pattern> (*) ")" [EOF]
    //
    //   ")" -> Shift(S47)
    //
    pub fn __state25<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Pattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state47(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 26
    //   (<Pattern> ",") = Pattern (*) "," ["("]
    //   (<Pattern> ",") = Pattern (*) "," [")"]
    //   (<Pattern> ",") = Pattern (*) "," [".."]
    //   (<Pattern> ",") = Pattern (*) "," ["::"]
    //   (<Pattern> ",") = Pattern (*) "," ["<"]
    //   (<Pattern> ",") = Pattern (*) "," ["Id"]
    //   (<Pattern> ",") = Pattern (*) "," ["_"]
    //   Pattern? = Pattern (*) [")"]
    //
    //   "," -> Shift(S48)
    //   ")" -> Reduce(Pattern? = Pattern => Call(ActionFn(156));)
    //
    pub fn __state26<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Pattern<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state48(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action156(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Pattern_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 27
    //   Comma<Pattern> = (<Pattern> ",")* Pattern? (*) [")"]
    //
    //   ")" -> Reduce(Comma<Pattern> = (<Pattern> ",")*, Pattern? => Call(ActionFn(78));)
    //
    pub fn __state27<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Pattern<TypeRef>>>,
        __sym1: &mut Option<::std::option::Option<Pattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action78(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cPattern_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 28
    //   (<Pattern> ",")* = (<Pattern> ",")* (<Pattern> ",") (*) ["("]
    //   (<Pattern> ",")* = (<Pattern> ",")* (<Pattern> ",") (*) [")"]
    //   (<Pattern> ",")* = (<Pattern> ",")* (<Pattern> ",") (*) [".."]
    //   (<Pattern> ",")* = (<Pattern> ",")* (<Pattern> ",") (*) ["::"]
    //   (<Pattern> ",")* = (<Pattern> ",")* (<Pattern> ",") (*) ["<"]
    //   (<Pattern> ",")* = (<Pattern> ",")* (<Pattern> ",") (*) ["Id"]
    //   (<Pattern> ",")* = (<Pattern> ",")* (<Pattern> ",") (*) ["_"]
    //
    //   "(" -> Reduce((<Pattern> ",")* = (<Pattern> ",")*, (<Pattern> ",") => Call(ActionFn(159));)
    //   "::" -> Reduce((<Pattern> ",")* = (<Pattern> ",")*, (<Pattern> ",") => Call(ActionFn(159));)
    //   "Id" -> Reduce((<Pattern> ",")* = (<Pattern> ",")*, (<Pattern> ",") => Call(ActionFn(159));)
    //   ")" -> Reduce((<Pattern> ",")* = (<Pattern> ",")*, (<Pattern> ",") => Call(ActionFn(159));)
    //   "<" -> Reduce((<Pattern> ",")* = (<Pattern> ",")*, (<Pattern> ",") => Call(ActionFn(159));)
    //   "_" -> Reduce((<Pattern> ",")* = (<Pattern> ",")*, (<Pattern> ",") => Call(ActionFn(159));)
    //   ".." -> Reduce((<Pattern> ",")* = (<Pattern> ",")*, (<Pattern> ",") => Call(ActionFn(159));)
    //
    pub fn __state28<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<Pattern<TypeRef>>>,
        __sym1: &mut Option<Pattern<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action159(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action159(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action159(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action159(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action159(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Underscore(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action159(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action159(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 29
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Path = (*) "::"? (<Id> "::")* Id ["("]
    //   Path = (*) "::"? (<Id> "::")* Id [")"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["{"]
    //   Pattern = @L (*) PatternKind @R [")"]
    //   Pattern = @L (*) PatternKind @R [","]
    //   PatternKind = (*) Path [")"]
    //   PatternKind = (*) Path [","]
    //   PatternKind = (*) Path "(" Comma<Pattern> ")" [")"]
    //   PatternKind = (*) Path "(" Comma<Pattern> ")" [","]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* FieldPattern? "}" [")"]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* FieldPattern? "}" [","]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* ".." "}" [")"]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* ".." "}" [","]
    //   PatternKind = (*) "(" Comma<Pattern> ")" [")"]
    //   PatternKind = (*) "(" Comma<Pattern> ")" [","]
    //   PatternKind = (*) ".." [")"]
    //   PatternKind = (*) ".." [","]
    //   PatternKind = (*) "<" TypeRef ">" [")"]
    //   PatternKind = (*) "<" TypeRef ">" [","]
    //   PatternKind = (*) "_" [")"]
    //   PatternKind = (*) "_" [","]
    //
    //   ".." -> Shift(S54)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "<" -> Shift(S50)
    //   "(" -> Shift(S51)
    //   "_" -> Shift(S55)
    //   "::" -> Shift(S6)
    //
    //   Path -> S49
    //   "::"? -> S53
    //   PatternKind -> S52
    pub fn __state29<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::DotDot(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state54(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state50(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state51(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Underscore(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state55(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state49(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state53(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::PatternKind(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state52(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 30
    //   PatternKind = "(" Comma<Pattern> ")" (*) [EOF]
    //
    //   EOF -> Reduce(PatternKind = "(", Comma<Pattern>, ")" => Call(ActionFn(63));)
    //
    pub fn __state30<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<Pattern<TypeRef>>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action63(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 31
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["<"]
    //   Id = (*) "Id" [">"]
    //   Path = "::"? (<Id> "::")* (*) Id ["<"]
    //   Path = "::"? (<Id> "::")* (*) Id [">"]
    //
    //   "Id" -> Shift(S57)
    //
    //   Id -> S56
    //   (<Id> "::") -> S40
    pub fn __state31<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state57(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state56(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state40(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 32
    //   Lifetime = "Lifetime" (*) ["&"]
    //   Lifetime = "Lifetime" (*) ["("]
    //   Lifetime = "Lifetime" (*) ["::"]
    //   Lifetime = "Lifetime" (*) ["Escape"]
    //   Lifetime = "Lifetime" (*) ["Id"]
    //   Lifetime = "Lifetime" (*) ["mut"]
    //
    //   "Id" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "::" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "Escape" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "mut" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "&" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   "(" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //
    pub fn __state32<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 33
    //   Lifetime? = Lifetime (*) ["&"]
    //   Lifetime? = Lifetime (*) ["("]
    //   Lifetime? = Lifetime (*) ["::"]
    //   Lifetime? = Lifetime (*) ["Escape"]
    //   Lifetime? = Lifetime (*) ["Id"]
    //   Lifetime? = Lifetime (*) ["mut"]
    //
    //   "mut" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "::" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "Id" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "&" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "Escape" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //   "(" -> Reduce(Lifetime? = Lifetime => Call(ActionFn(90));)
    //
    pub fn __state33<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Mut(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action90(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 34
    //   "mut"? = (*) ["&"]
    //   "mut"? = (*) ["("]
    //   "mut"? = (*) ["::"]
    //   "mut"? = (*) ["Escape"]
    //   "mut"? = (*) ["Id"]
    //   "mut"? = (*) "mut" ["&"]
    //   "mut"? = (*) "mut" ["("]
    //   "mut"? = (*) "mut" ["::"]
    //   "mut"? = (*) "mut" ["Escape"]
    //   "mut"? = (*) "mut" ["Id"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [">"]
    //
    //   "Id" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "&" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "(" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "Escape" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "::" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "mut" -> Shift(S59)
    //
    //   "mut"? -> S58
    pub fn __state34<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Mut(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state59(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22mut_22_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state58(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 35
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [">"]
    //
    //   ")" -> Shift(S60)
    //
    pub fn __state35<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state60(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 36
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["&"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["("]
    //   (<TypeRef> ",") = (*) TypeRef "," [")"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["::"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["Escape"]
    //   (<TypeRef> ",") = (*) TypeRef "," ["Id"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (*) (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (<TypeRef> ",")* (*) TypeRef? [")"]
    //   Escape = (*) "Escape" [")"]
    //   Escape = (*) "Escape" [","]
    //   Path = (*) "::"? (<Id> "::")* Id [")"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   TypeRef = (*) Escape [")"]
    //   TypeRef = (*) Escape [","]
    //   TypeRef = (*) Path [")"]
    //   TypeRef = (*) Path [","]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [")"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [")"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [","]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [")"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [","]
    //   TypeRef? = (*) [")"]
    //   TypeRef? = (*) TypeRef [")"]
    //
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "Escape" -> Shift(S67)
    //   "&" -> Shift(S66)
    //   "(" -> Shift(S62)
    //   ")" -> Reduce(TypeRef? =  => Call(ActionFn(142));)
    //   "::" -> Shift(S6)
    //
    //   (<TypeRef> ",") -> S61
    //   "::"? -> S68
    //   Escape -> S64
    //   TypeRef? -> S63
    //   Path -> S69
    //   TypeRef -> S65
    pub fn __state36<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state67(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state66(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state62(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action142(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::TypeRef_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state61(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state64(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::TypeRef_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state63(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state69(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state65(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 37
    //   PatternKind = "<" TypeRef ">" (*) [EOF]
    //
    //   EOF -> Reduce(PatternKind = "<", TypeRef, ">" => Call(ActionFn(62));)
    //
    pub fn __state37<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<TypeRef>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action62(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 38
    //   (<TypeRefOrLifetime> ",")* = (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (*) (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? [">"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [">"]
    //
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //
    //   (<TypeRefOrLifetime> ",")* -> S70
    //   Comma<TypeRefOrLifetime> -> S71
    pub fn __state38<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state70(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state71(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 39
    //   Id = "Id" (*) [EOF]
    //   Id = "Id" (*) ["("]
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["{"]
    //
    //   EOF -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "(" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "{" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state39<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 40
    //   (<Id> "::")* = (<Id> "::")* (<Id> "::") (*) ["Id"]
    //
    //   "Id" -> Reduce((<Id> "::")* = (<Id> "::")*, (<Id> "::") => Call(ActionFn(83));)
    //
    pub fn __state40<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<InternedString>>,
        __sym1: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action83(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 41
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) [EOF]
    //   Path = "::"? (<Id> "::")* Id (*) ["("]
    //   Path = "::"? (<Id> "::")* Id (*) ["{"]
    //
    //   "{" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S72)
    //   "(" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   EOF -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //
    pub fn __state41<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state72(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 42
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? (*) "}" [EOF]
    //
    //   "}" -> Shift(S73)
    //
    pub fn __state42<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<::std::option::Option<FieldPattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state73(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 43
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." (*) "}" [EOF]
    //
    //   "}" -> Shift(S74)
    //
    pub fn __state43<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state74(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 44
    //   FieldPattern = @L (*) Id @R ":" Pattern [","]
    //   FieldPattern = @L (*) Id @R ":" Pattern ["}"]
    //   Id = (*) "Id" [":"]
    //
    //   "Id" -> Shift(S76)
    //
    //   Id -> S75
    pub fn __state44<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state76(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state75(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 45
    //   (<FieldPattern> ",") = FieldPattern (*) "," [".."]
    //   (<FieldPattern> ",") = FieldPattern (*) "," ["Id"]
    //   (<FieldPattern> ",") = FieldPattern (*) "," ["}"]
    //   FieldPattern? = FieldPattern (*) ["}"]
    //
    //   "," -> Shift(S77)
    //   "}" -> Reduce(FieldPattern? = FieldPattern => Call(ActionFn(73));)
    //
    pub fn __state45<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<FieldPattern<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state77(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action73(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::FieldPattern_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 46
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (<FieldPattern> ",") (*) [".."]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (<FieldPattern> ",") (*) ["Id"]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (<FieldPattern> ",") (*) ["}"]
    //
    //   ".." -> Reduce((<FieldPattern> ",")* = (<FieldPattern> ",")*, (<FieldPattern> ",") => Call(ActionFn(76));)
    //   "Id" -> Reduce((<FieldPattern> ",")* = (<FieldPattern> ",")*, (<FieldPattern> ",") => Call(ActionFn(76));)
    //   "}" -> Reduce((<FieldPattern> ",")* = (<FieldPattern> ",")*, (<FieldPattern> ",") => Call(ActionFn(76));)
    //
    pub fn __state46<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym1: &mut Option<FieldPattern<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::DotDot(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action76(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action76(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action76(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 47
    //   PatternKind = Path "(" Comma<Pattern> ")" (*) [EOF]
    //
    //   EOF -> Reduce(PatternKind = Path, "(", Comma<Pattern>, ")" => Call(ActionFn(57));)
    //
    pub fn __state47<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Pattern<TypeRef>>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action57(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 48
    //   (<Pattern> ",") = Pattern "," (*) ["("]
    //   (<Pattern> ",") = Pattern "," (*) [")"]
    //   (<Pattern> ",") = Pattern "," (*) [".."]
    //   (<Pattern> ",") = Pattern "," (*) ["::"]
    //   (<Pattern> ",") = Pattern "," (*) ["<"]
    //   (<Pattern> ",") = Pattern "," (*) ["Id"]
    //   (<Pattern> ",") = Pattern "," (*) ["_"]
    //
    //   "(" -> Reduce((<Pattern> ",") = Pattern, "," => Call(ActionFn(160));)
    //   "_" -> Reduce((<Pattern> ",") = Pattern, "," => Call(ActionFn(160));)
    //   ")" -> Reduce((<Pattern> ",") = Pattern, "," => Call(ActionFn(160));)
    //   "Id" -> Reduce((<Pattern> ",") = Pattern, "," => Call(ActionFn(160));)
    //   "::" -> Reduce((<Pattern> ",") = Pattern, "," => Call(ActionFn(160));)
    //   ".." -> Reduce((<Pattern> ",") = Pattern, "," => Call(ActionFn(160));)
    //   "<" -> Reduce((<Pattern> ",") = Pattern, "," => Call(ActionFn(160));)
    //
    pub fn __state48<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Pattern<TypeRef>>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action160(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Underscore(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action160(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action160(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action160(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action160(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action160(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action160(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 49
    //   PatternKind = Path (*) [")"]
    //   PatternKind = Path (*) [","]
    //   PatternKind = Path (*) "(" Comma<Pattern> ")" [")"]
    //   PatternKind = Path (*) "(" Comma<Pattern> ")" [","]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* FieldPattern? "}" [")"]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* FieldPattern? "}" [","]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* ".." "}" [")"]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* ".." "}" [","]
    //
    //   ")" -> Reduce(PatternKind = Path => Call(ActionFn(64));)
    //   "{" -> Shift(S79)
    //   "," -> Reduce(PatternKind = Path => Call(ActionFn(64));)
    //   "(" -> Shift(S78)
    //
    pub fn __state49<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state79(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state78(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action64(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action64(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 50
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [">"]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id [">"]
    //   PatternKind = "<" (*) TypeRef ">" [")"]
    //   PatternKind = "<" (*) TypeRef ">" [","]
    //   TypeRef = (*) Escape [">"]
    //   TypeRef = (*) Path [">"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [">"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [">"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [">"]
    //
    //   "(" -> Shift(S18)
    //   "::" -> Shift(S6)
    //   "&" -> Shift(S17)
    //   "Escape" -> Shift(S22)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //
    //   Path -> S21
    //   TypeRef -> S80
    //   Escape -> S20
    //   "::"? -> S16
    pub fn __state50<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state18(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state17(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state22(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state21(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state80(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state20(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state16(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 51
    //   (<Pattern> ",")* = (*) ["("]
    //   (<Pattern> ",")* = (*) [")"]
    //   (<Pattern> ",")* = (*) [".."]
    //   (<Pattern> ",")* = (*) ["::"]
    //   (<Pattern> ",")* = (*) ["<"]
    //   (<Pattern> ",")* = (*) ["Id"]
    //   (<Pattern> ",")* = (*) ["_"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["("]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [")"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [".."]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["::"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["<"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["Id"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["_"]
    //   Comma<Pattern> = (*) (<Pattern> ",")* Pattern? [")"]
    //   PatternKind = "(" (*) Comma<Pattern> ")" [")"]
    //   PatternKind = "(" (*) Comma<Pattern> ")" [","]
    //
    //   ".." -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "<" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "(" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "Id" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   ")" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "::" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "_" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //
    //   (<Pattern> ",")* -> S14
    //   Comma<Pattern> -> S81
    pub fn __state51<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Underscore(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state14(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Comma_3cPattern_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state81(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 52
    //   @R = (*) [")"]
    //   @R = (*) [","]
    //   Pattern = @L PatternKind (*) @R [")"]
    //   Pattern = @L PatternKind (*) @R [","]
    //
    //   "," -> Reduce(@R =  => Lookbehind;)
    //   ")" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S82
    pub fn __state52<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<PatternKind<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state82(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 53
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id ["("]
    //   Path = "::"? (*) (<Id> "::")* Id [")"]
    //   Path = "::"? (*) (<Id> "::")* Id [","]
    //   Path = "::"? (*) (<Id> "::")* Id ["{"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S83
    pub fn __state53<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state83(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 54
    //   PatternKind = ".." (*) [")"]
    //   PatternKind = ".." (*) [","]
    //
    //   "," -> Reduce(PatternKind = ".." => Call(ActionFn(61));)
    //   ")" -> Reduce(PatternKind = ".." => Call(ActionFn(61));)
    //
    pub fn __state54<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action61(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action61(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 55
    //   PatternKind = "_" (*) [")"]
    //   PatternKind = "_" (*) [","]
    //
    //   "," -> Reduce(PatternKind = "_" => Call(ActionFn(60));)
    //   ")" -> Reduce(PatternKind = "_" => Call(ActionFn(60));)
    //
    pub fn __state55<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action60(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action60(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 56
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) ["<"]
    //   Path = "::"? (<Id> "::")* Id (*) [">"]
    //
    //   "<" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S72)
    //   ">" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //
    pub fn __state56<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state72(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 57
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["<"]
    //   Id = "Id" (*) [">"]
    //
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   ">" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state57<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 58
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [">"]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id [">"]
    //   TypeRef = (*) Escape [">"]
    //   TypeRef = (*) Path [">"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [">"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [">"]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [">"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [">"]
    //
    //   "Escape" -> Shift(S22)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "(" -> Shift(S18)
    //   "&" -> Shift(S17)
    //   "::" -> Shift(S6)
    //
    //   "::"? -> S16
    //   TypeRef -> S84
    //   Path -> S21
    //   Escape -> S20
    pub fn __state58<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state22(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state18(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state17(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state16(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state84(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state21(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state20(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 59
    //   "mut"? = "mut" (*) ["&"]
    //   "mut"? = "mut" (*) ["("]
    //   "mut"? = "mut" (*) ["::"]
    //   "mut"? = "mut" (*) ["Escape"]
    //   "mut"? = "mut" (*) ["Id"]
    //
    //   "Escape" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //   "Id" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //   "(" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //   "::" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //   "&" -> Reduce("mut"? = "mut" => Call(ActionFn(88));)
    //
    pub fn __state59<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action88(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 60
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [">"]
    //
    //   ">" -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //
    pub fn __state60<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 61
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["&"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["("]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) [")"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["::"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["Escape"]
    //   (<TypeRef> ",")* = (<TypeRef> ",")* (<TypeRef> ",") (*) ["Id"]
    //
    //   "(" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   "Escape" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   "Id" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   ")" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   "::" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //   "&" -> Reduce((<TypeRef> ",")* = (<TypeRef> ",")*, (<TypeRef> ",") => Call(ActionFn(144));)
    //
    pub fn __state61<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
        __sym1: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action144(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 62
    //   (<TypeRef> ",")* = (*) ["&"]
    //   (<TypeRef> ",")* = (*) ["("]
    //   (<TypeRef> ",")* = (*) [")"]
    //   (<TypeRef> ",")* = (*) ["::"]
    //   (<TypeRef> ",")* = (*) ["Escape"]
    //   (<TypeRef> ",")* = (*) ["Id"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (*) (<TypeRef> ",")* TypeRef? [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [","]
    //
    //   "(" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Escape" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "&" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "::" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Id" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   ")" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //
    //   Comma<TypeRef> -> S85
    //   (<TypeRef> ",")* -> S36
    pub fn __state62<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRef_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state85(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state36(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 63
    //   Comma<TypeRef> = (<TypeRef> ",")* TypeRef? (*) [")"]
    //
    //   ")" -> Reduce(Comma<TypeRef> = (<TypeRef> ",")*, TypeRef? => Call(ActionFn(92));)
    //
    pub fn __state63<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
        __sym1: &mut Option<::std::option::Option<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action92(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cTypeRef_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 64
    //   TypeRef = Escape (*) [")"]
    //   TypeRef = Escape (*) [","]
    //
    //   ")" -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //   "," -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //
    pub fn __state64<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 65
    //   (<TypeRef> ",") = TypeRef (*) "," ["&"]
    //   (<TypeRef> ",") = TypeRef (*) "," ["("]
    //   (<TypeRef> ",") = TypeRef (*) "," [")"]
    //   (<TypeRef> ",") = TypeRef (*) "," ["::"]
    //   (<TypeRef> ",") = TypeRef (*) "," ["Escape"]
    //   (<TypeRef> ",") = TypeRef (*) "," ["Id"]
    //   TypeRef? = TypeRef (*) [")"]
    //
    //   "," -> Shift(S86)
    //   ")" -> Reduce(TypeRef? = TypeRef => Call(ActionFn(141));)
    //
    pub fn __state65<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state86(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action141(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 66
    //   Lifetime = (*) "Lifetime" ["&"]
    //   Lifetime = (*) "Lifetime" ["("]
    //   Lifetime = (*) "Lifetime" ["::"]
    //   Lifetime = (*) "Lifetime" ["Escape"]
    //   Lifetime = (*) "Lifetime" ["Id"]
    //   Lifetime = (*) "Lifetime" ["mut"]
    //   Lifetime? = (*) ["&"]
    //   Lifetime? = (*) ["("]
    //   Lifetime? = (*) ["::"]
    //   Lifetime? = (*) ["Escape"]
    //   Lifetime? = (*) ["Id"]
    //   Lifetime? = (*) ["mut"]
    //   Lifetime? = (*) Lifetime ["&"]
    //   Lifetime? = (*) Lifetime ["("]
    //   Lifetime? = (*) Lifetime ["::"]
    //   Lifetime? = (*) Lifetime ["Escape"]
    //   Lifetime? = (*) Lifetime ["Id"]
    //   Lifetime? = (*) Lifetime ["mut"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [")"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [","]
    //
    //   "Escape" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "(" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "::" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Id" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Lifetime" -> Shift(S32)
    //   "mut" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "&" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //
    //   Lifetime -> S33
    //   Lifetime? -> S87
    pub fn __state66<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state32(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state33(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Lifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state87(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 67
    //   Escape = "Escape" (*) [")"]
    //   Escape = "Escape" (*) [","]
    //
    //   "," -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   ")" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state67<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 68
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id [")"]
    //   Path = "::"? (*) (<Id> "::")* Id [","]
    //   Path = "::"? (*) (<Id> "::")* Id ["<"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S88
    pub fn __state68<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state88(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 69
    //   TypeRef = Path (*) [")"]
    //   TypeRef = Path (*) [","]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [")"]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [","]
    //
    //   "<" -> Shift(S89)
    //   ")" -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //   "," -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //
    pub fn __state69<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state89(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 70
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["&"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["("]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["::"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," [">"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["Escape"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["Id"]
    //   (<TypeRefOrLifetime> ",") = (*) TypeRefOrLifetime "," ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (*) (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (<TypeRefOrLifetime> ",")* (*) TypeRefOrLifetime? [">"]
    //   Escape = (*) "Escape" [","]
    //   Escape = (*) "Escape" [">"]
    //   Lifetime = (*) "Lifetime" [","]
    //   Lifetime = (*) "Lifetime" [">"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id [">"]
    //   TypeRef = (*) Escape [","]
    //   TypeRef = (*) Escape [">"]
    //   TypeRef = (*) Path [","]
    //   TypeRef = (*) Path [">"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [">"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [","]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [">"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [","]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [">"]
    //   TypeRefOrLifetime = (*) Lifetime [","]
    //   TypeRefOrLifetime = (*) Lifetime [">"]
    //   TypeRefOrLifetime = (*) TypeRef [","]
    //   TypeRefOrLifetime = (*) TypeRef [">"]
    //   TypeRefOrLifetime? = (*) [">"]
    //   TypeRefOrLifetime? = (*) TypeRefOrLifetime [">"]
    //
    //   "Lifetime" -> Shift(S95)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "&" -> Shift(S94)
    //   "(" -> Shift(S93)
    //   "Escape" -> Shift(S97)
    //   ">" -> Reduce(TypeRefOrLifetime? =  => Call(ActionFn(147));)
    //   "::" -> Shift(S6)
    //
    //   TypeRefOrLifetime? -> S100
    //   TypeRefOrLifetime -> S99
    //   TypeRef -> S101
    //   Lifetime -> S98
    //   (<TypeRefOrLifetime> ",") -> S92
    //   "::"? -> S90
    //   Escape -> S96
    //   Path -> S91
    pub fn __state70<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state95(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state94(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state93(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state97(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action147(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::TypeRefOrLifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state100(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::TypeRefOrLifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state99(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state101(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state98(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state92(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state90(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state96(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state91(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 71
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [">"]
    //
    //   ">" -> Shift(S102)
    //
    pub fn __state71<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state102(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 72
    //   (<Id> "::") = Id "::" (*) ["Id"]
    //
    //   "Id" -> Reduce((<Id> "::") = Id, "::" => Call(ActionFn(84));)
    //
    pub fn __state72<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action84(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 73
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? "}" (*) [EOF]
    //
    //   EOF -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, FieldPattern?, "}" => Call(ActionFn(58));)
    //
    pub fn __state73<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<::std::option::Option<FieldPattern<TypeRef>>>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action58(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 74
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." "}" (*) [EOF]
    //
    //   EOF -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, "..", "}" => Call(ActionFn(59));)
    //
    pub fn __state74<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<Tok<'input>>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            None => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action59(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 75
    //   @R = (*) [":"]
    //   FieldPattern = @L Id (*) @R ":" Pattern [","]
    //   FieldPattern = @L Id (*) @R ":" Pattern ["}"]
    //
    //   ":" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S103
    pub fn __state75<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Colon(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state103(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 76
    //   Id = "Id" (*) [":"]
    //
    //   ":" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state76<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Colon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 77
    //   (<FieldPattern> ",") = FieldPattern "," (*) [".."]
    //   (<FieldPattern> ",") = FieldPattern "," (*) ["Id"]
    //   (<FieldPattern> ",") = FieldPattern "," (*) ["}"]
    //
    //   ".." -> Reduce((<FieldPattern> ",") = FieldPattern, "," => Call(ActionFn(77));)
    //   "}" -> Reduce((<FieldPattern> ",") = FieldPattern, "," => Call(ActionFn(77));)
    //   "Id" -> Reduce((<FieldPattern> ",") = FieldPattern, "," => Call(ActionFn(77));)
    //
    pub fn __state77<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<FieldPattern<TypeRef>>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::DotDot(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action77(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action77(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action77(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 78
    //   (<Pattern> ",")* = (*) ["("]
    //   (<Pattern> ",")* = (*) [")"]
    //   (<Pattern> ",")* = (*) [".."]
    //   (<Pattern> ",")* = (*) ["::"]
    //   (<Pattern> ",")* = (*) ["<"]
    //   (<Pattern> ",")* = (*) ["Id"]
    //   (<Pattern> ",")* = (*) ["_"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["("]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [")"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [".."]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["::"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["<"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["Id"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["_"]
    //   Comma<Pattern> = (*) (<Pattern> ",")* Pattern? [")"]
    //   PatternKind = Path "(" (*) Comma<Pattern> ")" [")"]
    //   PatternKind = Path "(" (*) Comma<Pattern> ")" [","]
    //
    //   ")" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "<" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   ".." -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "Id" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "::" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "_" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "(" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //
    //   (<Pattern> ",")* -> S14
    //   Comma<Pattern> -> S104
    pub fn __state78<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Underscore(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state14(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Comma_3cPattern_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state104(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 79
    //   (<FieldPattern> ",")* = (*) [".."]
    //   (<FieldPattern> ",")* = (*) ["Id"]
    //   (<FieldPattern> ",")* = (*) ["}"]
    //   (<FieldPattern> ",")* = (*) (<FieldPattern> ",")* (<FieldPattern> ",") [".."]
    //   (<FieldPattern> ",")* = (*) (<FieldPattern> ",")* (<FieldPattern> ",") ["Id"]
    //   (<FieldPattern> ",")* = (*) (<FieldPattern> ",")* (<FieldPattern> ",") ["}"]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* FieldPattern? "}" [")"]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* FieldPattern? "}" [","]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* ".." "}" [")"]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* ".." "}" [","]
    //
    //   "Id" -> Reduce((<FieldPattern> ",")* =  => Call(ActionFn(75));)
    //   ".." -> Reduce((<FieldPattern> ",")* =  => Call(ActionFn(75));)
    //   "}" -> Reduce((<FieldPattern> ",")* =  => Call(ActionFn(75));)
    //
    //   (<FieldPattern> ",")* -> S105
    pub fn __state79<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action75(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = super::__action75(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action75(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state105(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 80
    //   PatternKind = "<" TypeRef (*) ">" [")"]
    //   PatternKind = "<" TypeRef (*) ">" [","]
    //
    //   ">" -> Shift(S106)
    //
    pub fn __state80<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state106(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 81
    //   PatternKind = "(" Comma<Pattern> (*) ")" [")"]
    //   PatternKind = "(" Comma<Pattern> (*) ")" [","]
    //
    //   ")" -> Shift(S107)
    //
    pub fn __state81<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<Pattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state107(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 82
    //   Pattern = @L PatternKind @R (*) [")"]
    //   Pattern = @L PatternKind @R (*) [","]
    //
    //   ")" -> Reduce(Pattern = @L, PatternKind, @R => Call(ActionFn(56));)
    //   "," -> Reduce(Pattern = @L, PatternKind, @R => Call(ActionFn(56));)
    //
    pub fn __state82<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<PatternKind<TypeRef>>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action56(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Pattern(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action56(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Pattern(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 83
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" ["("]
    //   Id = (*) "Id" [")"]
    //   Id = (*) "Id" [","]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["{"]
    //   Path = "::"? (<Id> "::")* (*) Id ["("]
    //   Path = "::"? (<Id> "::")* (*) Id [")"]
    //   Path = "::"? (<Id> "::")* (*) Id [","]
    //   Path = "::"? (<Id> "::")* (*) Id ["{"]
    //
    //   "Id" -> Shift(S108)
    //
    //   (<Id> "::") -> S40
    //   Id -> S109
    pub fn __state83<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state108(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state40(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state109(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 84
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [">"]
    //
    //   ">" -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //
    pub fn __state84<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym3: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 85
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [")"]
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [","]
    //
    //   ")" -> Shift(S110)
    //
    pub fn __state85<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state110(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 86
    //   (<TypeRef> ",") = TypeRef "," (*) ["&"]
    //   (<TypeRef> ",") = TypeRef "," (*) ["("]
    //   (<TypeRef> ",") = TypeRef "," (*) [")"]
    //   (<TypeRef> ",") = TypeRef "," (*) ["::"]
    //   (<TypeRef> ",") = TypeRef "," (*) ["Escape"]
    //   (<TypeRef> ",") = TypeRef "," (*) ["Id"]
    //
    //   "Id" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   "&" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   "Escape" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   "(" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   ")" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //   "::" -> Reduce((<TypeRef> ",") = TypeRef, "," => Call(ActionFn(145));)
    //
    pub fn __state86<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action145(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 87
    //   "mut"? = (*) ["&"]
    //   "mut"? = (*) ["("]
    //   "mut"? = (*) ["::"]
    //   "mut"? = (*) ["Escape"]
    //   "mut"? = (*) ["Id"]
    //   "mut"? = (*) "mut" ["&"]
    //   "mut"? = (*) "mut" ["("]
    //   "mut"? = (*) "mut" ["::"]
    //   "mut"? = (*) "mut" ["Escape"]
    //   "mut"? = (*) "mut" ["Id"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [")"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [","]
    //
    //   "(" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "mut" -> Shift(S59)
    //   "&" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "Id" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "::" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "Escape" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //
    //   "mut"? -> S111
    pub fn __state87<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Mut(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state59(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22mut_22_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state111(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 88
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" [")"]
    //   Id = (*) "Id" [","]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["<"]
    //   Path = "::"? (<Id> "::")* (*) Id [")"]
    //   Path = "::"? (<Id> "::")* (*) Id [","]
    //   Path = "::"? (<Id> "::")* (*) Id ["<"]
    //
    //   "Id" -> Shift(S113)
    //
    //   (<Id> "::") -> S40
    //   Id -> S112
    pub fn __state88<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state113(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state40(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state112(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 89
    //   (<TypeRefOrLifetime> ",")* = (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (*) (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? [">"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [")"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [","]
    //
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //
    //   Comma<TypeRefOrLifetime> -> S114
    //   (<TypeRefOrLifetime> ",")* -> S70
    pub fn __state89<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state114(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state70(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 90
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id [","]
    //   Path = "::"? (*) (<Id> "::")* Id ["<"]
    //   Path = "::"? (*) (<Id> "::")* Id [">"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S115
    pub fn __state90<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state115(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 91
    //   TypeRef = Path (*) [","]
    //   TypeRef = Path (*) [">"]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = Path (*) "<" Comma<TypeRefOrLifetime> ">" [">"]
    //
    //   "<" -> Shift(S116)
    //   "," -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //   ">" -> Reduce(TypeRef = Path => Call(ActionFn(49));)
    //
    pub fn __state91<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state116(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action49(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 92
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") (*) ["Lifetime"]
    //
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* = (<TypeRefOrLifetime> ",")*, (<TypeRefOrLifetime> ",") => Call(ActionFn(149));)
    //
    pub fn __state92<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
        __sym1: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action149(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 93
    //   (<TypeRef> ",")* = (*) ["&"]
    //   (<TypeRef> ",")* = (*) ["("]
    //   (<TypeRef> ",")* = (*) [")"]
    //   (<TypeRef> ",")* = (*) ["::"]
    //   (<TypeRef> ",")* = (*) ["Escape"]
    //   (<TypeRef> ",")* = (*) ["Id"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["&"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["("]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") [")"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["::"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Escape"]
    //   (<TypeRef> ",")* = (*) (<TypeRef> ",")* (<TypeRef> ",") ["Id"]
    //   Comma<TypeRef> = (*) (<TypeRef> ",")* TypeRef? [")"]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [","]
    //   TypeRef = "(" (*) Comma<TypeRef> ")" [">"]
    //
    //   "&" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   ")" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Id" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "::" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "Escape" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //   "(" -> Reduce((<TypeRef> ",")* =  => Call(ActionFn(143));)
    //
    //   Comma<TypeRef> -> S117
    //   (<TypeRef> ",")* -> S36
    pub fn __state93<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action143(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRef_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state117(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_28_3cTypeRef_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state36(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 94
    //   Lifetime = (*) "Lifetime" ["&"]
    //   Lifetime = (*) "Lifetime" ["("]
    //   Lifetime = (*) "Lifetime" ["::"]
    //   Lifetime = (*) "Lifetime" ["Escape"]
    //   Lifetime = (*) "Lifetime" ["Id"]
    //   Lifetime = (*) "Lifetime" ["mut"]
    //   Lifetime? = (*) ["&"]
    //   Lifetime? = (*) ["("]
    //   Lifetime? = (*) ["::"]
    //   Lifetime? = (*) ["Escape"]
    //   Lifetime? = (*) ["Id"]
    //   Lifetime? = (*) ["mut"]
    //   Lifetime? = (*) Lifetime ["&"]
    //   Lifetime? = (*) Lifetime ["("]
    //   Lifetime? = (*) Lifetime ["::"]
    //   Lifetime? = (*) Lifetime ["Escape"]
    //   Lifetime? = (*) Lifetime ["Id"]
    //   Lifetime? = (*) Lifetime ["mut"]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [","]
    //   TypeRef = "&" (*) Lifetime? "mut"? TypeRef [">"]
    //
    //   "mut" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "::" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "&" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Escape" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Id" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "(" -> Reduce(Lifetime? =  => Call(ActionFn(91));)
    //   "Lifetime" -> Shift(S32)
    //
    //   Lifetime? -> S118
    //   Lifetime -> S33
    pub fn __state94<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Lifetime(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state32(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Mut(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action91(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::Lifetime_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Lifetime_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state118(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::Lifetime(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state33(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 95
    //   Lifetime = "Lifetime" (*) [","]
    //   Lifetime = "Lifetime" (*) [">"]
    //
    //   "," -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //   ">" -> Reduce(Lifetime = "Lifetime" => Call(ActionFn(70));)
    //
    pub fn __state95<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action70(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Lifetime(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 96
    //   TypeRef = Escape (*) [","]
    //   TypeRef = Escape (*) [">"]
    //
    //   ">" -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //   "," -> Reduce(TypeRef = Escape => TryCall(ActionFn(46));)
    //
    pub fn __state96<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = try!(super::__action46(text, __sym0));
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 97
    //   Escape = "Escape" (*) [","]
    //   Escape = "Escape" (*) [">"]
    //
    //   "," -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //   ">" -> Reduce(Escape = "Escape" => Call(ActionFn(69));)
    //
    pub fn __state97<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action69(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Escape(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 98
    //   TypeRefOrLifetime = Lifetime (*) [","]
    //   TypeRefOrLifetime = Lifetime (*) [">"]
    //
    //   "," -> Reduce(TypeRefOrLifetime = Lifetime => Call(ActionFn(51));)
    //   ">" -> Reduce(TypeRefOrLifetime = Lifetime => Call(ActionFn(51));)
    //
    pub fn __state98<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action51(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action51(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 99
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["&"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["("]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["::"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," [">"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["Escape"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["Id"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime (*) "," ["Lifetime"]
    //   TypeRefOrLifetime? = TypeRefOrLifetime (*) [">"]
    //
    //   ">" -> Reduce(TypeRefOrLifetime? = TypeRefOrLifetime => Call(ActionFn(146));)
    //   "," -> Shift(S119)
    //
    pub fn __state99<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Comma(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state119(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action146(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime_3f(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 100
    //   Comma<TypeRefOrLifetime> = (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? (*) [">"]
    //
    //   ">" -> Reduce(Comma<TypeRefOrLifetime> = (<TypeRefOrLifetime> ",")*, TypeRefOrLifetime? => Call(ActionFn(87));)
    //
    pub fn __state100<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::vec::Vec<TypeRef>>,
        __sym1: &mut Option<::std::option::Option<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action87(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 101
    //   TypeRefOrLifetime = TypeRef (*) [","]
    //   TypeRefOrLifetime = TypeRef (*) [">"]
    //
    //   ">" -> Reduce(TypeRefOrLifetime = TypeRef => Call(ActionFn(50));)
    //   "," -> Reduce(TypeRefOrLifetime = TypeRef => Call(ActionFn(50));)
    //
    pub fn __state101<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action50(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action50(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRefOrLifetime(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 102
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [">"]
    //
    //   ">" -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //
    pub fn __state102<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 103
    //   FieldPattern = @L Id @R (*) ":" Pattern [","]
    //   FieldPattern = @L Id @R (*) ":" Pattern ["}"]
    //
    //   ":" -> Shift(S120)
    //
    pub fn __state103<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<InternedString>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Colon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state120(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 104
    //   PatternKind = Path "(" Comma<Pattern> (*) ")" [")"]
    //   PatternKind = Path "(" Comma<Pattern> (*) ")" [","]
    //
    //   ")" -> Shift(S121)
    //
    pub fn __state104<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Pattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state121(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 105
    //   (<FieldPattern> ",") = (*) FieldPattern "," [".."]
    //   (<FieldPattern> ",") = (*) FieldPattern "," ["Id"]
    //   (<FieldPattern> ",") = (*) FieldPattern "," ["}"]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (*) (<FieldPattern> ",") [".."]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (*) (<FieldPattern> ",") ["Id"]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (*) (<FieldPattern> ",") ["}"]
    //   @L = (*) ["Id"]
    //   FieldPattern = (*) @L Id @R ":" Pattern [","]
    //   FieldPattern = (*) @L Id @R ":" Pattern ["}"]
    //   FieldPattern? = (*) ["}"]
    //   FieldPattern? = (*) FieldPattern ["}"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) FieldPattern? "}" [")"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) FieldPattern? "}" [","]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) ".." "}" [")"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) ".." "}" [","]
    //
    //   "}" -> Reduce(FieldPattern? =  => Call(ActionFn(74));)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   ".." -> Shift(S122)
    //
    //   FieldPattern -> S45
    //   FieldPattern? -> S123
    //   @L -> S44
    //   (<FieldPattern> ",") -> S46
    pub fn __state105<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::DotDot(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state122(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action74(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::FieldPattern_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::FieldPattern(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state45(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::FieldPattern_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state123(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::_40L(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state44(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state46(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 106
    //   PatternKind = "<" TypeRef ">" (*) [")"]
    //   PatternKind = "<" TypeRef ">" (*) [","]
    //
    //   ")" -> Reduce(PatternKind = "<", TypeRef, ">" => Call(ActionFn(62));)
    //   "," -> Reduce(PatternKind = "<", TypeRef, ">" => Call(ActionFn(62));)
    //
    pub fn __state106<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<TypeRef>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action62(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action62(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 107
    //   PatternKind = "(" Comma<Pattern> ")" (*) [")"]
    //   PatternKind = "(" Comma<Pattern> ")" (*) [","]
    //
    //   ")" -> Reduce(PatternKind = "(", Comma<Pattern>, ")" => Call(ActionFn(63));)
    //   "," -> Reduce(PatternKind = "(", Comma<Pattern>, ")" => Call(ActionFn(63));)
    //
    pub fn __state107<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<Pattern<TypeRef>>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action63(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action63(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 108
    //   Id = "Id" (*) ["("]
    //   Id = "Id" (*) [")"]
    //   Id = "Id" (*) [","]
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["{"]
    //
    //   ")" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "{" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "," -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "(" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state108<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 109
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) ["("]
    //   Path = "::"? (<Id> "::")* Id (*) [")"]
    //   Path = "::"? (<Id> "::")* Id (*) [","]
    //   Path = "::"? (<Id> "::")* Id (*) ["{"]
    //
    //   "(" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "{" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "," -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S72)
    //   ")" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //
    pub fn __state109<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state72(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 110
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [")"]
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [","]
    //
    //   ")" -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //   "," -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //
    pub fn __state110<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 111
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [")"]
    //   Escape = (*) "Escape" [","]
    //   Path = (*) "::"? (<Id> "::")* Id [")"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   TypeRef = (*) Escape [")"]
    //   TypeRef = (*) Escape [","]
    //   TypeRef = (*) Path [")"]
    //   TypeRef = (*) Path [","]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [")"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [")"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [","]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [")"]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [","]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [")"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [","]
    //
    //   "Escape" -> Shift(S67)
    //   "::" -> Shift(S6)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "(" -> Shift(S62)
    //   "&" -> Shift(S66)
    //
    //   TypeRef -> S124
    //   Path -> S69
    //   "::"? -> S68
    //   Escape -> S64
    pub fn __state111<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state67(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state62(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state66(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::TypeRef(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state124(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state69(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state68(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state64(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 112
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) [")"]
    //   Path = "::"? (<Id> "::")* Id (*) [","]
    //   Path = "::"? (<Id> "::")* Id (*) ["<"]
    //
    //   "::" -> Shift(S72)
    //   "<" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   ")" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "," -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //
    pub fn __state112<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state72(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 113
    //   Id = "Id" (*) [")"]
    //   Id = "Id" (*) [","]
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["<"]
    //
    //   ")" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "," -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state113<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 114
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [")"]
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [","]
    //
    //   ">" -> Shift(S125)
    //
    pub fn __state114<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state125(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 115
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" [","]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["<"]
    //   Id = (*) "Id" [">"]
    //   Path = "::"? (<Id> "::")* (*) Id [","]
    //   Path = "::"? (<Id> "::")* (*) Id ["<"]
    //   Path = "::"? (<Id> "::")* (*) Id [">"]
    //
    //   "Id" -> Shift(S126)
    //
    //   (<Id> "::") -> S40
    //   Id -> S127
    pub fn __state115<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state126(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state40(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state127(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 116
    //   (<TypeRefOrLifetime> ",")* = (*) ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) ["Lifetime"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["&"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["("]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["::"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") [">"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Escape"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Id"]
    //   (<TypeRefOrLifetime> ",")* = (*) (<TypeRefOrLifetime> ",")* (<TypeRefOrLifetime> ",") ["Lifetime"]
    //   Comma<TypeRefOrLifetime> = (*) (<TypeRefOrLifetime> ",")* TypeRefOrLifetime? [">"]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = Path "<" (*) Comma<TypeRefOrLifetime> ">" [">"]
    //
    //   ">" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "&" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",")* =  => Call(ActionFn(148));)
    //
    //   Comma<TypeRefOrLifetime> -> S128
    //   (<TypeRefOrLifetime> ",")* -> S70
    pub fn __state116<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __nt = super::__action148(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cTypeRefOrLifetime_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state128(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state70(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 117
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [","]
    //   TypeRef = "(" Comma<TypeRef> (*) ")" [">"]
    //
    //   ")" -> Shift(S129)
    //
    pub fn __state117<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state129(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 118
    //   "mut"? = (*) ["&"]
    //   "mut"? = (*) ["("]
    //   "mut"? = (*) ["::"]
    //   "mut"? = (*) ["Escape"]
    //   "mut"? = (*) ["Id"]
    //   "mut"? = (*) "mut" ["&"]
    //   "mut"? = (*) "mut" ["("]
    //   "mut"? = (*) "mut" ["::"]
    //   "mut"? = (*) "mut" ["Escape"]
    //   "mut"? = (*) "mut" ["Id"]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [","]
    //   TypeRef = "&" Lifetime? (*) "mut"? TypeRef [">"]
    //
    //   "&" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "mut" -> Shift(S59)
    //   "Escape" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "Id" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "::" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //   "(" -> Reduce("mut"? =  => Call(ActionFn(89));)
    //
    //   "mut"? -> S130
    pub fn __state118<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Mut(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state59(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            Some((_, Tok::Ampersand(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action89(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22mut_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_22mut_22_3f(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state130(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 119
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["&"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["("]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["::"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) [">"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["Escape"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["Id"]
    //   (<TypeRefOrLifetime> ",") = TypeRefOrLifetime "," (*) ["Lifetime"]
    //
    //   "&" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "::" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   ">" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "Escape" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "(" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "Lifetime" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //   "Id" -> Reduce((<TypeRefOrLifetime> ",") = TypeRefOrLifetime, "," => Call(ActionFn(150));)
    //
    pub fn __state119<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<TypeRef>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Ampersand(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Escape(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Lifetime(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            Some((_, Tok::Id(_), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __nt = super::__action150(text, __sym0, __sym1);
                return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cTypeRefOrLifetime_3e_20_22_2c_22_29(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 120
    //   @L = (*) ["("]
    //   @L = (*) [".."]
    //   @L = (*) ["::"]
    //   @L = (*) ["<"]
    //   @L = (*) ["Id"]
    //   @L = (*) ["_"]
    //   FieldPattern = @L Id @R ":" (*) Pattern [","]
    //   FieldPattern = @L Id @R ":" (*) Pattern ["}"]
    //   Pattern = (*) @L PatternKind @R [","]
    //   Pattern = (*) @L PatternKind @R ["}"]
    //
    //   "::" -> Reduce(@L =  => Lookahead;)
    //   "(" -> Reduce(@L =  => Lookahead;)
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "<" -> Reduce(@L =  => Lookahead;)
    //   ".." -> Reduce(@L =  => Lookahead;)
    //   "_" -> Reduce(@L =  => Lookahead;)
    //
    //   @L -> S131
    //   Pattern -> S132
    pub fn __state120<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<InternedString>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::Underscore(..), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym3.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state131(text, __lookbehind, __lookahead, __tokens, __sym4));
                }
                __Nonterminal::Pattern(__nt) => {
                    let __sym4 = &mut Some(__nt);
                    __result = try!(__state132(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 121
    //   PatternKind = Path "(" Comma<Pattern> ")" (*) [")"]
    //   PatternKind = Path "(" Comma<Pattern> ")" (*) [","]
    //
    //   ")" -> Reduce(PatternKind = Path, "(", Comma<Pattern>, ")" => Call(ActionFn(57));)
    //   "," -> Reduce(PatternKind = Path, "(", Comma<Pattern>, ")" => Call(ActionFn(57));)
    //
    pub fn __state121<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Pattern<TypeRef>>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action57(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action57(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 122
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." (*) "}" [")"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." (*) "}" [","]
    //
    //   "}" -> Shift(S133)
    //
    pub fn __state122<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state133(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 123
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? (*) "}" [")"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? (*) "}" [","]
    //
    //   "}" -> Shift(S134)
    //
    pub fn __state123<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<::std::option::Option<FieldPattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state134(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 124
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [")"]
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [","]
    //
    //   ")" -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //   "," -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //
    pub fn __state124<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym3: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 125
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [")"]
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [","]
    //
    //   ")" -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //   "," -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //
    pub fn __state125<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 126
    //   Id = "Id" (*) [","]
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["<"]
    //   Id = "Id" (*) [">"]
    //
    //   "<" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "," -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   ">" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state126<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 127
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) [","]
    //   Path = "::"? (<Id> "::")* Id (*) ["<"]
    //   Path = "::"? (<Id> "::")* Id (*) [">"]
    //
    //   "<" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S72)
    //   "," -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   ">" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //
    pub fn __state127<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state72(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 128
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [","]
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> (*) ">" [">"]
    //
    //   ">" -> Shift(S135)
    //
    pub fn __state128<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state135(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 129
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [","]
    //   TypeRef = "(" Comma<TypeRef> ")" (*) [">"]
    //
    //   "," -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //   ">" -> Reduce(TypeRef = "(", Comma<TypeRef>, ")" => Call(ActionFn(45));)
    //
    pub fn __state129<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<TypeRef>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action45(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 130
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [","]
    //   Escape = (*) "Escape" [">"]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id [">"]
    //   TypeRef = (*) Escape [","]
    //   TypeRef = (*) Escape [">"]
    //   TypeRef = (*) Path [","]
    //   TypeRef = (*) Path [">"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [","]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [">"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [","]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [">"]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [","]
    //   TypeRef = "&" Lifetime? "mut"? (*) TypeRef [">"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [","]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [">"]
    //
    //   "Escape" -> Shift(S97)
    //   "(" -> Shift(S93)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //   "&" -> Shift(S94)
    //   "::" -> Shift(S6)
    //
    //   Path -> S91
    //   Escape -> S96
    //   "::"? -> S90
    //   TypeRef -> S136
    pub fn __state130<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state97(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state93(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state94(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Path(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state91(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::Escape(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state96(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state90(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state136(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 131
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Path = (*) "::"? (<Id> "::")* Id ["("]
    //   Path = (*) "::"? (<Id> "::")* Id [","]
    //   Path = (*) "::"? (<Id> "::")* Id ["{"]
    //   Path = (*) "::"? (<Id> "::")* Id ["}"]
    //   Pattern = @L (*) PatternKind @R [","]
    //   Pattern = @L (*) PatternKind @R ["}"]
    //   PatternKind = (*) Path [","]
    //   PatternKind = (*) Path ["}"]
    //   PatternKind = (*) Path "(" Comma<Pattern> ")" [","]
    //   PatternKind = (*) Path "(" Comma<Pattern> ")" ["}"]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* FieldPattern? "}" [","]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* FieldPattern? "}" ["}"]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* ".." "}" [","]
    //   PatternKind = (*) Path "{" (<FieldPattern> ",")* ".." "}" ["}"]
    //   PatternKind = (*) "(" Comma<Pattern> ")" [","]
    //   PatternKind = (*) "(" Comma<Pattern> ")" ["}"]
    //   PatternKind = (*) ".." [","]
    //   PatternKind = (*) ".." ["}"]
    //   PatternKind = (*) "<" TypeRef ">" [","]
    //   PatternKind = (*) "<" TypeRef ">" ["}"]
    //   PatternKind = (*) "_" [","]
    //   PatternKind = (*) "_" ["}"]
    //
    //   "::" -> Shift(S6)
    //   ".." -> Shift(S137)
    //   "<" -> Shift(S143)
    //   "_" -> Shift(S141)
    //   "(" -> Shift(S138)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //
    //   PatternKind -> S139
    //   "::"? -> S140
    //   Path -> S142
    pub fn __state131<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::DotDot(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state137(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LessThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state143(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::Underscore(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state141(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state138(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::PatternKind(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state139(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state140(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state142(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 132
    //   FieldPattern = @L Id @R ":" Pattern (*) [","]
    //   FieldPattern = @L Id @R ":" Pattern (*) ["}"]
    //
    //   "," -> Reduce(FieldPattern = @L, Id, @R, ":", Pattern => Call(ActionFn(65));)
    //   "}" -> Reduce(FieldPattern = @L, Id, @R, ":", Pattern => Call(ActionFn(65));)
    //
    pub fn __state132<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<InternedString>,
        __sym2: &mut Option<usize>,
        __sym3: &mut Option<Tok<'input>>,
        __sym4: &mut Option<Pattern<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action65(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::FieldPattern(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action65(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::FieldPattern(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 133
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." "}" (*) [")"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." "}" (*) [","]
    //
    //   ")" -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, "..", "}" => Call(ActionFn(59));)
    //   "," -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, "..", "}" => Call(ActionFn(59));)
    //
    pub fn __state133<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<Tok<'input>>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action59(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action59(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 134
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? "}" (*) [")"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? "}" (*) [","]
    //
    //   "," -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, FieldPattern?, "}" => Call(ActionFn(58));)
    //   ")" -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, FieldPattern?, "}" => Call(ActionFn(58));)
    //
    pub fn __state134<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<::std::option::Option<FieldPattern<TypeRef>>>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action58(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action58(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 135
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [","]
    //   TypeRef = Path "<" Comma<TypeRefOrLifetime> ">" (*) [">"]
    //
    //   "," -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //   ">" -> Reduce(TypeRef = Path, "<", Comma<TypeRefOrLifetime>, ">" => Call(ActionFn(48));)
    //
    pub fn __state135<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<TypeRef>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action48(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 136
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [","]
    //   TypeRef = "&" Lifetime? "mut"? TypeRef (*) [">"]
    //
    //   ">" -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //   "," -> Reduce(TypeRef = "&", Lifetime?, "mut"?, TypeRef => Call(ActionFn(47));)
    //
    pub fn __state136<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<::std::option::Option<InternedString>>,
        __sym2: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym3: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::GreaterThan(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action47(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::TypeRef(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 137
    //   PatternKind = ".." (*) [","]
    //   PatternKind = ".." (*) ["}"]
    //
    //   "," -> Reduce(PatternKind = ".." => Call(ActionFn(61));)
    //   "}" -> Reduce(PatternKind = ".." => Call(ActionFn(61));)
    //
    pub fn __state137<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action61(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action61(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 138
    //   (<Pattern> ",")* = (*) ["("]
    //   (<Pattern> ",")* = (*) [")"]
    //   (<Pattern> ",")* = (*) [".."]
    //   (<Pattern> ",")* = (*) ["::"]
    //   (<Pattern> ",")* = (*) ["<"]
    //   (<Pattern> ",")* = (*) ["Id"]
    //   (<Pattern> ",")* = (*) ["_"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["("]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [")"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [".."]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["::"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["<"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["Id"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["_"]
    //   Comma<Pattern> = (*) (<Pattern> ",")* Pattern? [")"]
    //   PatternKind = "(" (*) Comma<Pattern> ")" [","]
    //   PatternKind = "(" (*) Comma<Pattern> ")" ["}"]
    //
    //   "::" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "_" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "(" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "Id" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   ".." -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "<" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   ")" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //
    //   Comma<Pattern> -> S144
    //   (<Pattern> ",")* -> S14
    pub fn __state138<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Underscore(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Comma_3cPattern_3e(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state144(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state14(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 139
    //   @R = (*) [","]
    //   @R = (*) ["}"]
    //   Pattern = @L PatternKind (*) @R [","]
    //   Pattern = @L PatternKind (*) @R ["}"]
    //
    //   "," -> Reduce(@R =  => Lookbehind;)
    //   "}" -> Reduce(@R =  => Lookbehind;)
    //
    //   @R -> S145
    pub fn __state139<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<PatternKind<TypeRef>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40R(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state145(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 140
    //   (<Id> "::")* = (*) ["Id"]
    //   (<Id> "::")* = (*) (<Id> "::")* (<Id> "::") ["Id"]
    //   Path = "::"? (*) (<Id> "::")* Id ["("]
    //   Path = "::"? (*) (<Id> "::")* Id [","]
    //   Path = "::"? (*) (<Id> "::")* Id ["{"]
    //   Path = "::"? (*) (<Id> "::")* Id ["}"]
    //
    //   "Id" -> Reduce((<Id> "::")* =  => Call(ActionFn(82));)
    //
    //   (<Id> "::")* -> S146
    pub fn __state140<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action82(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29_2a(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state146(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 141
    //   PatternKind = "_" (*) [","]
    //   PatternKind = "_" (*) ["}"]
    //
    //   "}" -> Reduce(PatternKind = "_" => Call(ActionFn(60));)
    //   "," -> Reduce(PatternKind = "_" => Call(ActionFn(60));)
    //
    pub fn __state141<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action60(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action60(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 142
    //   PatternKind = Path (*) [","]
    //   PatternKind = Path (*) ["}"]
    //   PatternKind = Path (*) "(" Comma<Pattern> ")" [","]
    //   PatternKind = Path (*) "(" Comma<Pattern> ")" ["}"]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* FieldPattern? "}" [","]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* FieldPattern? "}" ["}"]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* ".." "}" [","]
    //   PatternKind = Path (*) "{" (<FieldPattern> ",")* ".." "}" ["}"]
    //
    //   "{" -> Shift(S148)
    //   "," -> Reduce(PatternKind = Path => Call(ActionFn(64));)
    //   "}" -> Reduce(PatternKind = Path => Call(ActionFn(64));)
    //   "(" -> Shift(S147)
    //
    pub fn __state142<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::LeftBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state148(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state147(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action64(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action64(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 143
    //   "::"? = (*) ["Id"]
    //   "::"? = (*) "::" ["Id"]
    //   Escape = (*) "Escape" [">"]
    //   Path = (*) "::"? (<Id> "::")* Id ["<"]
    //   Path = (*) "::"? (<Id> "::")* Id [">"]
    //   PatternKind = "<" (*) TypeRef ">" [","]
    //   PatternKind = "<" (*) TypeRef ">" ["}"]
    //   TypeRef = (*) Escape [">"]
    //   TypeRef = (*) Path [">"]
    //   TypeRef = (*) Path "<" Comma<TypeRefOrLifetime> ">" [">"]
    //   TypeRef = (*) "&" Lifetime? "mut"? TypeRef [">"]
    //   TypeRef = (*) "(" Comma<TypeRef> ")" [">"]
    //
    //   "&" -> Shift(S17)
    //   "::" -> Shift(S6)
    //   "(" -> Shift(S18)
    //   "Escape" -> Shift(S22)
    //   "Id" -> Reduce("::"? =  => Call(ActionFn(86));)
    //
    //   Escape -> S20
    //   TypeRef -> S149
    //   "::"? -> S16
    //   Path -> S21
    pub fn __state143<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::Ampersand(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state17(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state6(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, __tok @ Tok::LeftParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state18(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Escape(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym1 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state22(text, __lookbehind, __lookahead, __tokens, __sym1));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action86(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_22_3a_3a_22_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym0.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Escape(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state20(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::TypeRef(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state149(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1));
                }
                __Nonterminal::_22_3a_3a_22_3f(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state16(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                __Nonterminal::Path(__nt) => {
                    let __sym1 = &mut Some(__nt);
                    __result = try!(__state21(text, __lookbehind, __lookahead, __tokens, __sym1));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 144
    //   PatternKind = "(" Comma<Pattern> (*) ")" [","]
    //   PatternKind = "(" Comma<Pattern> (*) ")" ["}"]
    //
    //   ")" -> Shift(S150)
    //
    pub fn __state144<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<Pattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state150(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 145
    //   Pattern = @L PatternKind @R (*) [","]
    //   Pattern = @L PatternKind @R (*) ["}"]
    //
    //   "}" -> Reduce(Pattern = @L, PatternKind, @R => Call(ActionFn(56));)
    //   "," -> Reduce(Pattern = @L, PatternKind, @R => Call(ActionFn(56));)
    //
    pub fn __state145<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<usize>,
        __sym1: &mut Option<PatternKind<TypeRef>>,
        __sym2: &mut Option<usize>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action56(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Pattern(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action56(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Pattern(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 146
    //   (<Id> "::") = (*) Id "::" ["Id"]
    //   (<Id> "::")* = (<Id> "::")* (*) (<Id> "::") ["Id"]
    //   Id = (*) "Id" ["("]
    //   Id = (*) "Id" [","]
    //   Id = (*) "Id" ["::"]
    //   Id = (*) "Id" ["{"]
    //   Id = (*) "Id" ["}"]
    //   Path = "::"? (<Id> "::")* (*) Id ["("]
    //   Path = "::"? (<Id> "::")* (*) Id [","]
    //   Path = "::"? (<Id> "::")* (*) Id ["{"]
    //   Path = "::"? (<Id> "::")* (*) Id ["}"]
    //
    //   "Id" -> Shift(S152)
    //
    //   Id -> S151
    //   (<Id> "::") -> S40
    pub fn __state146<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(__tok0), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok0));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state152(text, __lookbehind, __lookahead, __tokens, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::Id(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state151(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                __Nonterminal::_28_3cId_3e_20_22_3a_3a_22_29(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state40(text, __lookbehind, __lookahead, __tokens, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 147
    //   (<Pattern> ",")* = (*) ["("]
    //   (<Pattern> ",")* = (*) [")"]
    //   (<Pattern> ",")* = (*) [".."]
    //   (<Pattern> ",")* = (*) ["::"]
    //   (<Pattern> ",")* = (*) ["<"]
    //   (<Pattern> ",")* = (*) ["Id"]
    //   (<Pattern> ",")* = (*) ["_"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["("]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [")"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") [".."]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["::"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["<"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["Id"]
    //   (<Pattern> ",")* = (*) (<Pattern> ",")* (<Pattern> ",") ["_"]
    //   Comma<Pattern> = (*) (<Pattern> ",")* Pattern? [")"]
    //   PatternKind = Path "(" (*) Comma<Pattern> ")" [","]
    //   PatternKind = Path "(" (*) Comma<Pattern> ")" ["}"]
    //
    //   ")" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "::" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "<" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "Id" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "(" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   "_" -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //   ".." -> Reduce((<Pattern> ",")* =  => Call(ActionFn(158));)
    //
    //   (<Pattern> ",")* -> S14
    //   Comma<Pattern> -> S153
    pub fn __state147<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LessThan(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::Underscore(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = super::__action158(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cPattern_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state14(text, __lookbehind, __lookahead, __tokens, __sym2));
                }
                __Nonterminal::Comma_3cPattern_3e(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state153(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 148
    //   (<FieldPattern> ",")* = (*) [".."]
    //   (<FieldPattern> ",")* = (*) ["Id"]
    //   (<FieldPattern> ",")* = (*) ["}"]
    //   (<FieldPattern> ",")* = (*) (<FieldPattern> ",")* (<FieldPattern> ",") [".."]
    //   (<FieldPattern> ",")* = (*) (<FieldPattern> ",")* (<FieldPattern> ",") ["Id"]
    //   (<FieldPattern> ",")* = (*) (<FieldPattern> ",")* (<FieldPattern> ",") ["}"]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* FieldPattern? "}" [","]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* FieldPattern? "}" ["}"]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* ".." "}" [","]
    //   PatternKind = Path "{" (*) (<FieldPattern> ",")* ".." "}" ["}"]
    //
    //   "Id" -> Reduce((<FieldPattern> ",")* =  => Call(ActionFn(75));)
    //   "}" -> Reduce((<FieldPattern> ",")* =  => Call(ActionFn(75));)
    //   ".." -> Reduce((<FieldPattern> ",")* =  => Call(ActionFn(75));)
    //
    //   (<FieldPattern> ",")* -> S154
    pub fn __state148<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Id(_), _)) => {
                let __nt = super::__action75(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action75(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            Some((_, Tok::DotDot(..), _)) => {
                let __nt = super::__action75(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym1.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29_2a(__nt) => {
                    let __sym2 = &mut Some(__nt);
                    __result = try!(__state154(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 149
    //   PatternKind = "<" TypeRef (*) ">" [","]
    //   PatternKind = "<" TypeRef (*) ">" ["}"]
    //
    //   ">" -> Shift(S155)
    //
    pub fn __state149<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<TypeRef>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::GreaterThan(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym2 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state155(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 150
    //   PatternKind = "(" Comma<Pattern> ")" (*) [","]
    //   PatternKind = "(" Comma<Pattern> ")" (*) ["}"]
    //
    //   "}" -> Reduce(PatternKind = "(", Comma<Pattern>, ")" => Call(ActionFn(63));)
    //   "," -> Reduce(PatternKind = "(", Comma<Pattern>, ")" => Call(ActionFn(63));)
    //
    pub fn __state150<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<Vec<Pattern<TypeRef>>>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action63(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action63(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 151
    //   (<Id> "::") = Id (*) "::" ["Id"]
    //   Path = "::"? (<Id> "::")* Id (*) ["("]
    //   Path = "::"? (<Id> "::")* Id (*) [","]
    //   Path = "::"? (<Id> "::")* Id (*) ["{"]
    //   Path = "::"? (<Id> "::")* Id (*) ["}"]
    //
    //   "(" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "{" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "::" -> Shift(S72)
    //   "}" -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //   "," -> Reduce(Path = "::"?, (<Id> "::")*, Id => Call(ActionFn(52));)
    //
    pub fn __state151<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<::std::option::Option<Tok<'input>>>,
        __sym1: &mut Option<::std::vec::Vec<InternedString>>,
        __sym2: &mut Option<InternedString>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::ColonColon(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state72(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action52(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Path(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 152
    //   Id = "Id" (*) ["("]
    //   Id = "Id" (*) [","]
    //   Id = "Id" (*) ["::"]
    //   Id = "Id" (*) ["{"]
    //   Id = "Id" (*) ["}"]
    //
    //   "," -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "(" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "}" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "::" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //   "{" -> Reduce(Id = "Id" => Call(ActionFn(68));)
    //
    pub fn __state152<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<&'input str>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LeftParen(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::ColonColon(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            Some((_, Tok::LeftBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __nt = super::__action68(text, __sym0);
                return Ok((__lookbehind, __lookahead, __Nonterminal::Id(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 153
    //   PatternKind = Path "(" Comma<Pattern> (*) ")" [","]
    //   PatternKind = Path "(" Comma<Pattern> (*) ")" ["}"]
    //
    //   ")" -> Shift(S156)
    //
    pub fn __state153<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Pattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightParen(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state156(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 154
    //   (<FieldPattern> ",") = (*) FieldPattern "," [".."]
    //   (<FieldPattern> ",") = (*) FieldPattern "," ["Id"]
    //   (<FieldPattern> ",") = (*) FieldPattern "," ["}"]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (*) (<FieldPattern> ",") [".."]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (*) (<FieldPattern> ",") ["Id"]
    //   (<FieldPattern> ",")* = (<FieldPattern> ",")* (*) (<FieldPattern> ",") ["}"]
    //   @L = (*) ["Id"]
    //   FieldPattern = (*) @L Id @R ":" Pattern [","]
    //   FieldPattern = (*) @L Id @R ":" Pattern ["}"]
    //   FieldPattern? = (*) ["}"]
    //   FieldPattern? = (*) FieldPattern ["}"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) FieldPattern? "}" [","]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) FieldPattern? "}" ["}"]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) ".." "}" [","]
    //   PatternKind = Path "{" (<FieldPattern> ",")* (*) ".." "}" ["}"]
    //
    //   "Id" -> Reduce(@L =  => Lookahead;)
    //   "}" -> Reduce(FieldPattern? =  => Call(ActionFn(74));)
    //   ".." -> Shift(S158)
    //
    //   @L -> S44
    //   (<FieldPattern> ",") -> S46
    //   FieldPattern? -> S157
    //   FieldPattern -> S45
    pub fn __state154<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::DotDot(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym3 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state158(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
            }
            Some((_, Tok::Id(_), _)) => {
                let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
                __result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __nt = super::__action74(text, );
                __result = (__lookbehind, __lookahead, __Nonterminal::FieldPattern_3f(__nt));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        while __sym2.is_some() {
            let (__lookbehind, __lookahead, __nt) = __result;
            match __nt {
                __Nonterminal::_40L(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state44(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                __Nonterminal::_28_3cFieldPattern_3e_20_22_2c_22_29(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state46(text, __lookbehind, __lookahead, __tokens, __sym2, __sym3));
                }
                __Nonterminal::FieldPattern_3f(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state157(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3));
                }
                __Nonterminal::FieldPattern(__nt) => {
                    let __sym3 = &mut Some(__nt);
                    __result = try!(__state45(text, __lookbehind, __lookahead, __tokens, __sym3));
                }
                _ => {
                    return Ok((__lookbehind, __lookahead, __nt));
                }
            }
        }
        return Ok(__result);
    }

    // State 155
    //   PatternKind = "<" TypeRef ">" (*) [","]
    //   PatternKind = "<" TypeRef ">" (*) ["}"]
    //
    //   "," -> Reduce(PatternKind = "<", TypeRef, ">" => Call(ActionFn(62));)
    //   "}" -> Reduce(PatternKind = "<", TypeRef, ">" => Call(ActionFn(62));)
    //
    pub fn __state155<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Tok<'input>>,
        __sym1: &mut Option<TypeRef>,
        __sym2: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action62(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __nt = super::__action62(text, __sym0, __sym1, __sym2);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 156
    //   PatternKind = Path "(" Comma<Pattern> ")" (*) [","]
    //   PatternKind = Path "(" Comma<Pattern> ")" (*) ["}"]
    //
    //   "," -> Reduce(PatternKind = Path, "(", Comma<Pattern>, ")" => Call(ActionFn(57));)
    //   "}" -> Reduce(PatternKind = Path, "(", Comma<Pattern>, ")" => Call(ActionFn(57));)
    //
    pub fn __state156<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<Vec<Pattern<TypeRef>>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action57(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __nt = super::__action57(text, __sym0, __sym1, __sym2, __sym3);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 157
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? (*) "}" [","]
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? (*) "}" ["}"]
    //
    //   "}" -> Shift(S159)
    //
    pub fn __state157<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<::std::option::Option<FieldPattern<TypeRef>>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state159(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 158
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." (*) "}" [","]
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." (*) "}" ["}"]
    //
    //   "}" -> Shift(S160)
    //
    pub fn __state158<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, __tok @ Tok::RightBrace(..), __loc)) => {
                let mut __lookbehind = Some(__loc);
                let mut __sym4 = &mut Some((__tok));
                let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
                __result = try!(__state160(text, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3, __sym4));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
        return Ok(__result);
    }

    // State 159
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? "}" (*) [","]
    //   PatternKind = Path "{" (<FieldPattern> ",")* FieldPattern? "}" (*) ["}"]
    //
    //   "," -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, FieldPattern?, "}" => Call(ActionFn(58));)
    //   "}" -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, FieldPattern?, "}" => Call(ActionFn(58));)
    //
    pub fn __state159<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<::std::option::Option<FieldPattern<TypeRef>>>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action58(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action58(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }

    // State 160
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." "}" (*) [","]
    //   PatternKind = Path "{" (<FieldPattern> ",")* ".." "}" (*) ["}"]
    //
    //   "}" -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, "..", "}" => Call(ActionFn(59));)
    //   "," -> Reduce(PatternKind = Path, "{", (<FieldPattern> ",")*, "..", "}" => Call(ActionFn(59));)
    //
    pub fn __state160<
        'input,
        __TOKENS: Iterator<Item=Result<(usize, Tok<'input>, usize),tok::Error>>,
    >(
        text: &'input str,
        __lookbehind: Option<usize>,
        __lookahead: Option<(usize, Tok<'input>, usize)>,
        __tokens: &mut __TOKENS,
        __sym0: &mut Option<Path>,
        __sym1: &mut Option<Tok<'input>>,
        __sym2: &mut Option<::std::vec::Vec<FieldPattern<TypeRef>>>,
        __sym3: &mut Option<Tok<'input>>,
        __sym4: &mut Option<Tok<'input>>,
    ) -> Result<(Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >), __ParseError<usize,Tok<'input>,tok::Error>>
    {
        let mut __result: (Option<usize>, Option<(usize, Tok<'input>, usize)>, __Nonterminal<'input, >);
        match __lookahead {
            Some((_, Tok::RightBrace(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action59(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            Some((_, Tok::Comma(..), _)) => {
                let __sym0 = __sym0.take().unwrap();
                let __sym1 = __sym1.take().unwrap();
                let __sym2 = __sym2.take().unwrap();
                let __sym3 = __sym3.take().unwrap();
                let __sym4 = __sym4.take().unwrap();
                let __nt = super::__action59(text, __sym0, __sym1, __sym2, __sym3, __sym4);
                return Ok((__lookbehind, __lookahead, __Nonterminal::PatternKind(__nt)));
            }
            _ => {
                return Err(__ParseError::UnrecognizedToken {
                    token: __lookahead,
                    expected: vec![],
                });
            }
        }
    }
}

pub fn __action0<
    'input,
>(
    text: &'input str,
    __0: Grammar,
) -> Grammar
{
    (__0)
}

pub fn __action1<
    'input,
>(
    text: &'input str,
    __0: Pattern<TypeRef>,
) -> Pattern<TypeRef>
{
    (__0)
}

pub fn __action2<
    'input,
>(
    text: &'input str,
    uses: ::std::vec::Vec<GrammarItem>,
    lo: usize,
    _: Tok<'input>,
    hi: usize,
    tps: ::std::option::Option<Vec<TypeParameter>>,
    parameters: ::std::option::Option<Vec<Parameter>>,
    where_clauses: ::std::option::Option<Vec<&'input str>>,
    _: Tok<'input>,
    items: ::std::vec::Vec<GrammarItem>,
) -> Grammar
{
    {
        let where_clauses =
            where_clauses.iter()
                         .flat_map(|wc| wc.iter())
                         .map(|s| s.to_string())
                         .collect();
        Grammar { span: Span(lo, hi),
                  type_parameters: tps.unwrap_or(vec![]),
                  parameters: parameters.unwrap_or(vec![]),
                  where_clauses: where_clauses,
                  items: uses.into_iter().chain(items).collect() }
    }
}

pub fn __action3<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    __0: Vec<TypeParameter>,
    _: Tok<'input>,
) -> Vec<TypeParameter>
{
    (__0)
}

pub fn __action4<
    'input,
>(
    text: &'input str,
    l: &'input str,
) -> TypeParameter
{
    TypeParameter::Lifetime(intern(l))
}

pub fn __action5<
    'input,
>(
    text: &'input str,
    l: &'input str,
) -> TypeParameter
{
    TypeParameter::Id(intern(l))
}

pub fn __action6<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    __0: Vec<Parameter>,
    _: Tok<'input>,
) -> Vec<Parameter>
{
    (__0)
}

pub fn __action7<
    'input,
>(
    text: &'input str,
    id: InternedString,
    _: Tok<'input>,
    ty: TypeRef,
) -> Parameter
{
    Parameter { name: id, ty: ty }
}

pub fn __action8<
    'input,
>(
    text: &'input str,
    __0: GrammarItem,
) -> GrammarItem
{
    (__0)
}

pub fn __action9<
    'input,
>(
    text: &'input str,
    __0: GrammarItem,
) -> GrammarItem
{
    (__0)
}

pub fn __action10<
    'input,
>(
    text: &'input str,
    __0: GrammarItem,
) -> GrammarItem
{
    (__0)
}

pub fn __action11<
    'input,
>(
    text: &'input str,
    u: &'input str,
    _: Tok<'input>,
) -> GrammarItem
{
    GrammarItem::Use(u.to_string())
}

pub fn __action12<
    'input,
>(
    text: &'input str,
    p: ::std::option::Option<Tok<'input>>,
    lo: usize,
    n: (NonterminalString, Vec<NonterminalString>),
    hi: usize,
    t: ::std::option::Option<TypeRef>,
    _: Tok<'input>,
    a: Vec<Alternative>,
) -> GrammarItem
{
    {
        GrammarItem::Nonterminal(NonterminalData { public: p.is_some(),
                                                   span: Span(lo, hi),
                                                   name: n.0,
                                                   args: n.1,
                                                   type_decl: t,
                                                   alternatives: a })
    }
}

pub fn __action13<
    'input,
>(
    text: &'input str,
    __0: NonterminalString,
    _: Tok<'input>,
    __1: Vec<NonterminalString>,
    _: Tok<'input>,
) -> (NonterminalString, Vec<NonterminalString>)
{
    (__0, __1)
}

pub fn __action14<
    'input,
>(
    text: &'input str,
    n: NonterminalString,
) -> (NonterminalString, Vec<NonterminalString>)
{
    (n, vec![])
}

pub fn __action15<
    'input,
>(
    text: &'input str,
    __0: &'input str,
) -> (NonterminalString, Vec<NonterminalString>)
{
    (NonterminalString(intern(__0)), vec![])
}

pub fn __action16<
    'input,
>(
    text: &'input str,
    a: Alternative,
) -> Vec<Alternative>
{
    vec![a]
}

pub fn __action17<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    __0: ::std::vec::Vec<Alternative>,
    _: Tok<'input>,
    _: Tok<'input>,
) -> Vec<Alternative>
{
    (__0)
}

pub fn __action18<
    'input,
>(
    text: &'input str,
    lo: usize,
    s: ExprSymbol,
    c: ::std::option::Option<Condition>,
    a: ::std::option::Option<ActionKind>,
    _: Tok<'input>,
    hi: usize,
) -> Alternative
{
    {
        Alternative {
            span: Span(lo, hi),
            expr: s,
            condition: c,
            action: a
        }
    }
}

pub fn __action19<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> ActionKind
{
    ActionKind::Lookahead
}

pub fn __action20<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> ActionKind
{
    ActionKind::Lookbehind
}

pub fn __action21<
    'input,
>(
    text: &'input str,
    c: &'input str,
) -> ActionKind
{
    ActionKind::User(c.to_string())
}

pub fn __action22<
    'input,
>(
    text: &'input str,
    c: &'input str,
) -> ActionKind
{
    ActionKind::Fallible(c.to_string())
}

pub fn __action23<
    'input,
>(
    text: &'input str,
    lo: usize,
    a: NonterminalString,
    op: ConditionOp,
    b: InternedString,
    hi: usize,
) -> Condition
{
    {
        Condition { span:Span(lo, hi), lhs:a, rhs:b, op:op }
    }
}

pub fn __action24<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> ConditionOp
{
    ConditionOp::Equals
}

pub fn __action25<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> ConditionOp
{
    ConditionOp::NotEquals
}

pub fn __action26<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> ConditionOp
{
    ConditionOp::Match
}

pub fn __action27<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> ConditionOp
{
    ConditionOp::NotMatch
}

pub fn __action28<
    'input,
>(
    text: &'input str,
    __0: ::std::vec::Vec<Symbol>,
) -> ExprSymbol
{
    ExprSymbol { symbols: __0 }
}

pub fn __action29<
    'input,
>(
    text: &'input str,
    lo: usize,
    _: Tok<'input>,
    _: usize,
    l: InternedString,
    _: Tok<'input>,
    s: Symbol,
    _: Tok<'input>,
    hi: usize,
) -> Symbol
{
    Symbol::new(Span(lo, hi), SymbolKind::Name(l, Box::new(s)))
}

pub fn __action30<
    'input,
>(
    text: &'input str,
    lo: usize,
    _: Tok<'input>,
    s: Symbol,
    _: Tok<'input>,
    hi: usize,
) -> Symbol
{
    Symbol::new(Span(lo, hi), SymbolKind::Choose(Box::new(s)))
}

pub fn __action31<
    'input,
>(
    text: &'input str,
    __0: Symbol,
) -> Symbol
{
    (__0)
}

pub fn __action32<
    'input,
>(
    text: &'input str,
    __0: Symbol,
) -> Symbol
{
    (__0)
}

pub fn __action33<
    'input,
>(
    text: &'input str,
    lhs: Symbol,
    op: RepeatOp,
    hi: usize,
) -> Symbol
{
    Symbol::new(Span(lhs.span.0, hi),
                    SymbolKind::Repeat(Box::new(RepeatSymbol { symbol: lhs, op: op })))
}

pub fn __action34<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> RepeatOp
{
    RepeatOp::Plus
}

pub fn __action35<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> RepeatOp
{
    RepeatOp::Star
}

pub fn __action36<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> RepeatOp
{
    RepeatOp::Question
}

pub fn __action37<
    'input,
>(
    text: &'input str,
    lo: usize,
    sk: SymbolKind,
    hi: usize,
) -> Symbol
{
    Symbol::new(Span(lo, hi), sk)
}

pub fn __action38<
    'input,
>(
    text: &'input str,
    name: NonterminalString,
    _: Tok<'input>,
    args: Vec<Symbol>,
    _: Tok<'input>,
) -> SymbolKind
{
    SymbolKind::Macro(MacroSymbol { name: name, args: args })
}

pub fn __action39<
    'input,
>(
    text: &'input str,
    __0: TerminalString,
) -> SymbolKind
{
    SymbolKind::Terminal(__0)
}

pub fn __action40<
    'input,
>(
    text: &'input str,
    __0: NonterminalString,
) -> SymbolKind
{
    SymbolKind::Nonterminal(__0)
}

pub fn __action41<
    'input,
>(
    text: &'input str,
    __0: InternedString,
) -> SymbolKind
{
    SymbolKind::Nonterminal(NonterminalString(__0))
}

pub fn __action42<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    __0: ExprSymbol,
    _: Tok<'input>,
) -> SymbolKind
{
    SymbolKind::Expr(__0)
}

pub fn __action43<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> SymbolKind
{
    SymbolKind::Lookahead
}

pub fn __action44<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> SymbolKind
{
    SymbolKind::Lookbehind
}

pub fn __action45<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    __0: Vec<TypeRef>,
    _: Tok<'input>,
) -> TypeRef
{
    TypeRef::Tuple(__0)
}

pub fn __action46<
    'input,
>(
    text: &'input str,
    e: InternedString,
) -> Result<TypeRef,__ParseError<usize,Tok<'input>,tok::Error>>
{
    {
        panic!("parse escape symbol")
    }
}

pub fn __action47<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    l: ::std::option::Option<InternedString>,
    m: ::std::option::Option<Tok<'input>>,
    t: TypeRef,
) -> TypeRef
{
    TypeRef::Ref { lifetime: l,
                       mutable: m.is_some(),
                       referent: Box::new(t) }
}

pub fn __action48<
    'input,
>(
    text: &'input str,
    p: Path,
    _: Tok<'input>,
    a: Vec<TypeRef>,
    _: Tok<'input>,
) -> TypeRef
{
    TypeRef::Nominal { path: p, types: a }
}

pub fn __action49<
    'input,
>(
    text: &'input str,
    p: Path,
) -> TypeRef
{
    match p.as_id() {
            Some(id) => TypeRef::Id(id),
            None => TypeRef::Nominal { path: p, types: vec![] }
        }
}

pub fn __action50<
    'input,
>(
    text: &'input str,
    __0: TypeRef,
) -> TypeRef
{
    (__0)
}

pub fn __action51<
    'input,
>(
    text: &'input str,
    __0: InternedString,
) -> TypeRef
{
    TypeRef::Lifetime(__0)
}

pub fn __action52<
    'input,
>(
    text: &'input str,
    a: ::std::option::Option<Tok<'input>>,
    h: ::std::vec::Vec<InternedString>,
    t: InternedString,
) -> Path
{
    {
        Path { absolute: a.is_some(),
               ids: h.into_iter().chain(once(t)).collect() }
    }
}

pub fn __action53<
    'input,
>(
    text: &'input str,
    lo0: usize,
    _: Tok<'input>,
    _: Tok<'input>,
    hi0: usize,
    _: Tok<'input>,
    a0: ::std::vec::Vec<AssociatedType>,
    _: Tok<'input>,
    lo: usize,
    t: TypeRef,
    hi: usize,
    _: Tok<'input>,
    c: Vec<Conversion>,
    _: Tok<'input>,
    a1: ::std::vec::Vec<AssociatedType>,
    _: Tok<'input>,
) -> GrammarItem
{
    {
        GrammarItem::ExternToken(ExternToken {
            span: Span(lo0, hi0),
            associated_types: a0.into_iter().chain(a1).collect(),
            enum_token: EnumToken {
                type_name: t,
                type_span: Span(lo, hi),
                conversions: c,
            }
        })
    }
}

pub fn __action54<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    lo: usize,
    n: InternedString,
    hi: usize,
    _: Tok<'input>,
    t: TypeRef,
    _: Tok<'input>,
) -> AssociatedType
{
    {
        AssociatedType { type_span: Span(lo, hi),
                         type_name: n,
                         type_ref: t }
    }
}

pub fn __action55<
    'input,
>(
    text: &'input str,
    lo: usize,
    from: TerminalString,
    p: &'input str,
    hi: usize,
) -> Result<Conversion,__ParseError<usize,Tok<'input>,tok::Error>>
{
    {
        panic!("not yet implemented -- parse pattern")
    }
}

pub fn __action56<
    'input,
>(
    text: &'input str,
    lo: usize,
    k: PatternKind<TypeRef>,
    hi: usize,
) -> Pattern<TypeRef>
{
    Pattern { span: Span(lo, hi), kind: k }
}

pub fn __action57<
    'input,
>(
    text: &'input str,
    __0: Path,
    _: Tok<'input>,
    __1: Vec<Pattern<TypeRef>>,
    _: Tok<'input>,
) -> PatternKind<TypeRef>
{
    PatternKind::Enum(__0, __1)
}

pub fn __action58<
    'input,
>(
    text: &'input str,
    p: Path,
    _: Tok<'input>,
    a0: ::std::vec::Vec<FieldPattern<TypeRef>>,
    a1: ::std::option::Option<FieldPattern<TypeRef>>,
    _: Tok<'input>,
) -> PatternKind<TypeRef>
{
    PatternKind::Struct(p, a0.into_iter().chain(a1).collect(), false)
}

pub fn __action59<
    'input,
>(
    text: &'input str,
    p: Path,
    _: Tok<'input>,
    a0: ::std::vec::Vec<FieldPattern<TypeRef>>,
    _: Tok<'input>,
    _: Tok<'input>,
) -> PatternKind<TypeRef>
{
    PatternKind::Struct(p, a0, true)
}

pub fn __action60<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> PatternKind<TypeRef>
{
    PatternKind::Underscore
}

pub fn __action61<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> PatternKind<TypeRef>
{
    PatternKind::DotDot
}

pub fn __action62<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    __0: TypeRef,
    _: Tok<'input>,
) -> PatternKind<TypeRef>
{
    PatternKind::Choose(__0)
}

pub fn __action63<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    __0: Vec<Pattern<TypeRef>>,
    _: Tok<'input>,
) -> PatternKind<TypeRef>
{
    PatternKind::Tuple(__0)
}

pub fn __action64<
    'input,
>(
    text: &'input str,
    __0: Path,
) -> PatternKind<TypeRef>
{
    PatternKind::Path(__0)
}

pub fn __action65<
    'input,
>(
    text: &'input str,
    lo: usize,
    id: InternedString,
    hi: usize,
    _: Tok<'input>,
    pat: Pattern<TypeRef>,
) -> FieldPattern<TypeRef>
{
    {
        FieldPattern { field_span: Span(lo, hi),
                       field_name: id,
                       pattern: pat }
    }
}

pub fn __action66<
    'input,
>(
    text: &'input str,
    i: &'input str,
) -> NonterminalString
{
    NonterminalString(intern(i))
}

pub fn __action67<
    'input,
>(
    text: &'input str,
    i: InternedString,
) -> NonterminalString
{
    NonterminalString(i)
}

pub fn __action68<
    'input,
>(
    text: &'input str,
    i: &'input str,
) -> InternedString
{
    intern(i)
}

pub fn __action69<
    'input,
>(
    text: &'input str,
    i: &'input str,
) -> InternedString
{
    intern(i)
}

pub fn __action70<
    'input,
>(
    text: &'input str,
    i: &'input str,
) -> InternedString
{
    intern(i)
}

pub fn __action71<
    'input,
>(
    text: &'input str,
    s: InternedString,
) -> TerminalString
{
    TerminalString(s)
}

pub fn __action72<
    'input,
>(
    text: &'input str,
    s: &'input str,
) -> InternedString
{
    intern(s)
}

pub fn __action73<
    'input,
>(
    text: &'input str,
    __0: FieldPattern<TypeRef>,
) -> ::std::option::Option<FieldPattern<TypeRef>>
{
    Some(__0)
}

pub fn __action74<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<FieldPattern<TypeRef>>
{
    None
}

pub fn __action75<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<FieldPattern<TypeRef>>
{
    vec![]
}

pub fn __action76<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<FieldPattern<TypeRef>>,
    e: FieldPattern<TypeRef>,
) -> ::std::vec::Vec<FieldPattern<TypeRef>>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action77<
    'input,
>(
    text: &'input str,
    __0: FieldPattern<TypeRef>,
    _: Tok<'input>,
) -> FieldPattern<TypeRef>
{
    (__0)
}

pub fn __action78<
    'input,
>(
    text: &'input str,
    v0: ::std::vec::Vec<Pattern<TypeRef>>,
    e1: ::std::option::Option<Pattern<TypeRef>>,
) -> Vec<Pattern<TypeRef>>
{
    v0.into_iter().chain(e1).collect()
}

pub fn __action79<
    'input,
>(
    text: &'input str,
    v0: ::std::vec::Vec<Conversion>,
    e1: ::std::option::Option<Conversion>,
) -> Vec<Conversion>
{
    v0.into_iter().chain(e1).collect()
}

pub fn __action80<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<AssociatedType>
{
    vec![]
}

pub fn __action81<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<AssociatedType>,
    e: AssociatedType,
) -> ::std::vec::Vec<AssociatedType>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action82<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<InternedString>
{
    vec![]
}

pub fn __action83<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<InternedString>,
    e: InternedString,
) -> ::std::vec::Vec<InternedString>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action84<
    'input,
>(
    text: &'input str,
    __0: InternedString,
    _: Tok<'input>,
) -> InternedString
{
    (__0)
}

pub fn __action85<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> ::std::option::Option<Tok<'input>>
{
    Some(__0)
}

pub fn __action86<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Tok<'input>>
{
    None
}

pub fn __action87<
    'input,
>(
    text: &'input str,
    v0: ::std::vec::Vec<TypeRef>,
    e1: ::std::option::Option<TypeRef>,
) -> Vec<TypeRef>
{
    v0.into_iter().chain(e1).collect()
}

pub fn __action88<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> ::std::option::Option<Tok<'input>>
{
    Some(__0)
}

pub fn __action89<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Tok<'input>>
{
    None
}

pub fn __action90<
    'input,
>(
    text: &'input str,
    __0: InternedString,
) -> ::std::option::Option<InternedString>
{
    Some(__0)
}

pub fn __action91<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<InternedString>
{
    None
}

pub fn __action92<
    'input,
>(
    text: &'input str,
    v0: ::std::vec::Vec<TypeRef>,
    e1: ::std::option::Option<TypeRef>,
) -> Vec<TypeRef>
{
    v0.into_iter().chain(e1).collect()
}

pub fn __action93<
    'input,
>(
    text: &'input str,
    v0: ::std::vec::Vec<Symbol>,
    e1: ::std::option::Option<Symbol>,
) -> Vec<Symbol>
{
    v0.into_iter().chain(e1).collect()
}

pub fn __action94<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<Symbol>
{
    vec![]
}

pub fn __action95<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<Symbol>,
    e: Symbol,
) -> ::std::vec::Vec<Symbol>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action96<
    'input,
>(
    text: &'input str,
    __0: ActionKind,
) -> ::std::option::Option<ActionKind>
{
    Some(__0)
}

pub fn __action97<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<ActionKind>
{
    None
}

pub fn __action98<
    'input,
>(
    text: &'input str,
    __0: Condition,
) -> ::std::option::Option<Condition>
{
    Some(__0)
}

pub fn __action99<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Condition>
{
    None
}

pub fn __action100<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    __0: Condition,
) -> Condition
{
    (__0)
}

pub fn __action101<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<Alternative>
{
    vec![]
}

pub fn __action102<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<Alternative>,
    e: Alternative,
) -> ::std::vec::Vec<Alternative>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action103<
    'input,
>(
    text: &'input str,
    v0: ::std::vec::Vec<NonterminalString>,
    e1: ::std::option::Option<NonterminalString>,
) -> Vec<NonterminalString>
{
    v0.into_iter().chain(e1).collect()
}

pub fn __action104<
    'input,
>(
    text: &'input str,
    __0: TypeRef,
) -> ::std::option::Option<TypeRef>
{
    Some(__0)
}

pub fn __action105<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<TypeRef>
{
    None
}

pub fn __action106<
    'input,
>(
    text: &'input str,
    _: Tok<'input>,
    __0: TypeRef,
) -> TypeRef
{
    (__0)
}

pub fn __action107<
    'input,
>(
    text: &'input str,
    __0: Tok<'input>,
) -> ::std::option::Option<Tok<'input>>
{
    Some(__0)
}

pub fn __action108<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Tok<'input>>
{
    None
}

pub fn __action109<
    'input,
>(
    text: &'input str,
    v0: ::std::vec::Vec<Parameter>,
    e1: ::std::option::Option<Parameter>,
) -> Vec<Parameter>
{
    v0.into_iter().chain(e1).collect()
}

pub fn __action110<
    'input,
>(
    text: &'input str,
    v0: ::std::vec::Vec<TypeParameter>,
    e1: ::std::option::Option<TypeParameter>,
) -> Vec<TypeParameter>
{
    v0.into_iter().chain(e1).collect()
}

pub fn __action111<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<GrammarItem>
{
    vec![]
}

pub fn __action112<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<GrammarItem>,
    e: GrammarItem,
) -> ::std::vec::Vec<GrammarItem>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action113<
    'input,
>(
    text: &'input str,
    __0: Vec<&'input str>,
) -> ::std::option::Option<Vec<&'input str>>
{
    Some(__0)
}

pub fn __action114<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Vec<&'input str>>
{
    None
}

pub fn __action115<
    'input,
>(
    text: &'input str,
    __0: Vec<Parameter>,
) -> ::std::option::Option<Vec<Parameter>>
{
    Some(__0)
}

pub fn __action116<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Vec<Parameter>>
{
    None
}

pub fn __action117<
    'input,
>(
    text: &'input str,
    __0: Vec<TypeParameter>,
) -> ::std::option::Option<Vec<TypeParameter>>
{
    Some(__0)
}

pub fn __action118<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Vec<TypeParameter>>
{
    None
}

pub fn __action119<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<GrammarItem>
{
    vec![]
}

pub fn __action120<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<GrammarItem>,
    e: GrammarItem,
) -> ::std::vec::Vec<GrammarItem>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action121<
    'input,
>(
    text: &'input str,
    __0: TypeParameter,
) -> ::std::option::Option<TypeParameter>
{
    Some(__0)
}

pub fn __action122<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<TypeParameter>
{
    None
}

pub fn __action123<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<TypeParameter>
{
    vec![]
}

pub fn __action124<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<TypeParameter>,
    e: TypeParameter,
) -> ::std::vec::Vec<TypeParameter>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action125<
    'input,
>(
    text: &'input str,
    __0: TypeParameter,
    _: Tok<'input>,
) -> TypeParameter
{
    (__0)
}

pub fn __action126<
    'input,
>(
    text: &'input str,
    __0: Parameter,
) -> ::std::option::Option<Parameter>
{
    Some(__0)
}

pub fn __action127<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Parameter>
{
    None
}

pub fn __action128<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<Parameter>
{
    vec![]
}

pub fn __action129<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<Parameter>,
    e: Parameter,
) -> ::std::vec::Vec<Parameter>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action130<
    'input,
>(
    text: &'input str,
    __0: Parameter,
    _: Tok<'input>,
) -> Parameter
{
    (__0)
}

pub fn __action131<
    'input,
>(
    text: &'input str,
    __0: NonterminalString,
) -> ::std::option::Option<NonterminalString>
{
    Some(__0)
}

pub fn __action132<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<NonterminalString>
{
    None
}

pub fn __action133<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<NonterminalString>
{
    vec![]
}

pub fn __action134<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<NonterminalString>,
    e: NonterminalString,
) -> ::std::vec::Vec<NonterminalString>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action135<
    'input,
>(
    text: &'input str,
    __0: NonterminalString,
    _: Tok<'input>,
) -> NonterminalString
{
    (__0)
}

pub fn __action136<
    'input,
>(
    text: &'input str,
    __0: Symbol,
) -> ::std::option::Option<Symbol>
{
    Some(__0)
}

pub fn __action137<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Symbol>
{
    None
}

pub fn __action138<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<Symbol>
{
    vec![]
}

pub fn __action139<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<Symbol>,
    e: Symbol,
) -> ::std::vec::Vec<Symbol>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action140<
    'input,
>(
    text: &'input str,
    __0: Symbol,
    _: Tok<'input>,
) -> Symbol
{
    (__0)
}

pub fn __action141<
    'input,
>(
    text: &'input str,
    __0: TypeRef,
) -> ::std::option::Option<TypeRef>
{
    Some(__0)
}

pub fn __action142<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<TypeRef>
{
    None
}

pub fn __action143<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<TypeRef>
{
    vec![]
}

pub fn __action144<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<TypeRef>,
    e: TypeRef,
) -> ::std::vec::Vec<TypeRef>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action145<
    'input,
>(
    text: &'input str,
    __0: TypeRef,
    _: Tok<'input>,
) -> TypeRef
{
    (__0)
}

pub fn __action146<
    'input,
>(
    text: &'input str,
    __0: TypeRef,
) -> ::std::option::Option<TypeRef>
{
    Some(__0)
}

pub fn __action147<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<TypeRef>
{
    None
}

pub fn __action148<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<TypeRef>
{
    vec![]
}

pub fn __action149<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<TypeRef>,
    e: TypeRef,
) -> ::std::vec::Vec<TypeRef>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action150<
    'input,
>(
    text: &'input str,
    __0: TypeRef,
    _: Tok<'input>,
) -> TypeRef
{
    (__0)
}

pub fn __action151<
    'input,
>(
    text: &'input str,
    __0: Conversion,
) -> ::std::option::Option<Conversion>
{
    Some(__0)
}

pub fn __action152<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Conversion>
{
    None
}

pub fn __action153<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<Conversion>
{
    vec![]
}

pub fn __action154<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<Conversion>,
    e: Conversion,
) -> ::std::vec::Vec<Conversion>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action155<
    'input,
>(
    text: &'input str,
    __0: Conversion,
    _: Tok<'input>,
) -> Conversion
{
    (__0)
}

pub fn __action156<
    'input,
>(
    text: &'input str,
    __0: Pattern<TypeRef>,
) -> ::std::option::Option<Pattern<TypeRef>>
{
    Some(__0)
}

pub fn __action157<
    'input,
>(
    text: &'input str,
) -> ::std::option::Option<Pattern<TypeRef>>
{
    None
}

pub fn __action158<
    'input,
>(
    text: &'input str,
) -> ::std::vec::Vec<Pattern<TypeRef>>
{
    vec![]
}

pub fn __action159<
    'input,
>(
    text: &'input str,
    v: ::std::vec::Vec<Pattern<TypeRef>>,
    e: Pattern<TypeRef>,
) -> ::std::vec::Vec<Pattern<TypeRef>>
{
    { let mut v = v; v.push(e); v }
}

pub fn __action160<
    'input,
>(
    text: &'input str,
    __0: Pattern<TypeRef>,
    _: Tok<'input>,
) -> Pattern<TypeRef>
{
    (__0)
}

pub trait __ToTriple<'input, > {
    type Error;
    fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize),Self::Error>;
}

impl<'input, > __ToTriple<'input, > for (usize, Tok<'input>, usize) {
    type Error = tok::Error;
    fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize),tok::Error> {
        Ok(value)
    }
}
impl<'input, > __ToTriple<'input, > for Result<(usize, Tok<'input>, usize),tok::Error> {
    type Error = tok::Error;
    fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize),tok::Error> {
        value
    }
}