gramatica 0.2.1

// Manually editted the results of aplying bootstrapper.rs to from_1_to_2.rsg

extern crate gramatica;

use std::cmp::Ordering;
use gramatica::{Associativity,EarleyKind,State,Parser,ParsingTablesTrait,AmbiguityInfo};
use std::env;
use std::fs::File;
use std::io::prelude::*;
use std::rc::Rc;
use std::collections::HashMap;
use std::fmt::{self,Display,Formatter};


#[derive(Clone,Debug,PartialEq)]
enum PatKind
{
	Fixme,
	Underscore,
	Ref(Rc<PatKind>),
	RefMut(Rc<PatKind>),
	Void,
	Tuple(Vec<PatKind>),
	Path(PathKind),
	EnumEmpty(Rc<Token>),
	Enum(Rc<Token>,Vec<PatKind>),//name,tuple
	BindedIdent(BindKind,String),
}

#[derive(Clone,Debug,PartialEq)]
enum TyKind
{
	Fixme,
	Underscore,
	Ref(Rc<TyKind>),
	RefMut(Rc<TyKind>),
	RefLifetime(String,bool,Rc<TyKind>),//lifetime,mut,type
	Void,
	Path(PathWKind),
	Tuple(Vec<TyLf>),
}

#[derive(Clone,Debug,PartialEq)]
enum ExprKind
{
	Fixme,
	Single(Rc<Token>),
	Member(Rc<ExprKind>,PathKind),//object, attribute_or_method
	Index(Rc<ExprKind>,Option<Rc<ExprKind>>),//object, index
	Call(Rc<ExprKind>,Vec<ExprKind>),//function,arguments
	Parentheses(Vec<ExprKind>),
	Infix(Rc<ExprKind>,Rc<Token>,Rc<ExprKind>),//left,symbol,right
	Ref(Rc<ExprKind>),
	RefMut(Rc<ExprKind>),
	Prefix(Rc<Token>,Rc<ExprKind>),//symbol,operand
	Lambda(Vec<(PatKind,Option<TyLf>)>,Option<TyKind>,Rc<ExprKind>),//params,optional return,expression
	Struct(PathKind,Vec<(String,Option<ExprKind>)>),//path to struct name, initializations
	Range(Option<Rc<ExprKind>>,Option<Rc<ExprKind>>),
	Return(Option<Rc<ExprKind>>),
	Break(Option<String>),
}

#[derive(Clone,Debug,PartialEq)]
enum StmtKind
{
	Let(PatKind,Option<TyLf>,Option<ExprKind>),
	Item(Vec<AttrKind>,ItemKind),//attributes, item
	Block(Vec<AttrKind>,Rc<Token>),//attributes, block
	Expr(Vec<AttrKind>,ExprKind),//attributes, expression
	Empty,
}

#[derive(Clone,Debug,PartialEq)]
enum AttrKind
{
	Documentation(String),
	Flag(String),
	Value(String,Rc<Token>),
	Sequence(String,Vec<AttrKind>),
}

//With colons
#[derive(Clone,Debug,PartialEq)]
enum PathKind
{
	Fixme,
	Ident(String),
	Super,
	Absolute(Rc<PathKind>),
	FromSelf(Rc<PathKind>),
	StepIdent(Rc<PathKind>,String),
	StepSuper(Rc<PathKind>),
	GenericArgs(Rc<PathKind>,Vec<TyLf>),
	Literal(Rc<Token>),
}

//Without colons
#[derive(Clone,Debug,PartialEq)]
enum PathWKind
{
	Fixme,
	Ident(String),
	IdentGeneric(String,Vec<TyLf>),
	Function(String,Vec<TyLf>,Rc<Token>),
	StepIdent(Rc<PathWKind>,String),
	StepIdentGeneric(Rc<PathWKind>,String,Vec<TyLf>),
	StepFunction(Rc<PathWKind>,String,Vec<TyLf>,Rc<Token>),
}

//No types
#[derive(Clone,Debug,PartialEq)]
enum PathNKind
{
	Fixme,
	Ident(String),
	AbsoluteIdent(String),
	FromSelf,
	AbsoluteSelf,
	Super,
	AbsoluteSuper,
	Step(Rc<PathNKind>,String),
}

#[derive(Clone,Debug,PartialEq)]
enum ViewKind
{
	Fixme,
	Path(PathNKind,Option<String>),
	All(Option<PathNKind>),
	Selection(Option<PathNKind>,Vec<String>),
	ExternCrate(String,Option<String>),//crate id, as name
}

#[derive(Clone,Debug,PartialEq)]
enum BindKind
{
	Ref,
	RefMut,
	Mut,
}

#[derive(Clone,Debug,PartialEq)]
enum ItemKind
{
	Fixme,
	Macro(Rc<Token>,Option<Rc<Token>>,Rc<Token>),
	FN(String, Vec<String>,Vec<String>,Vec<(PatKind,TyLf)>,Option<TyKind>,Vec<StmtKind>,Option<ExprKind>),//name, lifetimes, generic params, params(pattern,type), return type, block statements, block expression
	Method(String, Vec<String>,Vec<String>,bool,bool,bool,Option<TyLf>,Vec<(PatKind,TyLf)>,Option<TyKind>,Vec<StmtKind>,Option<ExprKind>),//name, lifetimes, generic params, has_self, has_ref, has_mut, self_type, params(pattern,type), return type, block statements, block expression
	Terminal(String,Option<Rc<Token>>,Vec<ItemKind>),
	Nonterminal(String,Option<Rc<Token>>,Vec<Rc<Token>>),
	View(ViewKind),
	Enum(String,Vec<String>,Vec<String>,Vec<(String,Vec<TyLf>)>),//name, lifetimes, params, defs
	Impl(Vec<String>,Vec<String>,Option<PathWKind>,TyLf,Vec<ItemKind>),//lifetimes, generic params, optional path of trait, type of the thing being implemented, subitems
	Struct(String,Vec<String>,Vec<String>,Vec<(String,TyLf)>),//name, lifetimes, generic params, fields
}

#[derive(Clone,Debug,PartialEq)]
enum TyLf
{
	Type(TyKind),
	Lifetime(String),
}

#[derive(Clone,Debug,PartialEq)]
enum Token{DummyStart,
Static,Mut,Const,Crate,Extern,As,Struct,Enum,Union,Mod,Unsafe,FN,Pub,LittleSelf,Type,For,Trait,DEFAULT,Impl,Where,Super,BOX,Ref,Typeof,
StaticLifetime,Continue,Return,Break,Yield,Move,Match,If,Else,LiteralLet,While,Loop,In,True,False,Catch,Use,Terminal,Nonterminal,
ShebangLine,LitInteger(usize),LiteralLifetime(String),LitByte,LitChar(char),LitFloat,LitStr(String),LitStrRaw,LitByteStr,LitByteStrRaw,NoSpace,
InnerDocComment,OuterDocComment(String),LiteralIdent(String),Shebang,NumberSign,FatArrow,EqualEqual,NE,Equal,LArrow,RArrow,LE,GE,MinusEqual,
AndEqual,OrEqual,PlusEqual,StarEqual,SlashEqual,CaretEqual,PercentEqual,Underscore,OrOr,Vertical,Comma,AndAnd,Ampersand,DotDotDot,DotDot,
Dot,ModSep,Colon,Caret,Slash,Percent,Semicolon,Bang,At,Star,QuestionMark,LBracket,RBracket,LPar,RPar,LBrace,RBrace,LT,GT,Plus,Minus,
WholeCrate(Vec<Rc<Token>>),MaybeShebang,MaybeInnerAttrs,InnerAttrs,InnerAttr,MaybeOuterAttrs(Vec<AttrKind>),OuterAttrs(Vec<AttrKind>),
OuterAttr(AttrKind),MetaItem(AttrKind),MetaSeq(Vec<AttrKind>),MaybeModItems(Vec<Rc<Token>>),ModItems(Vec<Rc<Token>>),
AttrsAndVis(Vec<AttrKind>),ModItem(Vec<AttrKind>, ItemKind),Item(ItemKind),StmtItem(ItemKind),ItemStatic,ItemConst,
ItemMacro(ItemKind),ViewItem(ViewKind),ExternFnItem,UseItem(ViewKind),ViewPath(ViewKind),BlockItem(ItemKind),MaybeTyAscription(Option<TyLf>),
MaybeInitExpr(Option<ExprKind>),ItemStruct(ItemKind),StructDeclArgs(Vec<(String,TyLf)>),StructTupleArgs,StructDeclFields(Vec<(String,TyLf)>),StructDeclField(String,TyLf),StructTupleFields,StructTupleField,ItemEnum(ItemKind),
EnumDefs(Vec<(String,Vec<TyLf>)>),EnumDef(String,Vec<TyLf>),EnumArgs(Vec<TyLf>),ItemUnion,ItemMod,ItemForeignMod,MaybeAbi,MaybeForeignItems,ForeignItems,ForeignItem,ItemForeignStatic,
ItemForeignFn,FnDeclAllowVariadic,FnParamsAllowVariadic,Visibility,IdentsOrSelf(Vec<String>),IdentOrSelf(String),ItemType,ForSized,ItemTrait,MaybeTraitItems,
TraitItems,TraitItem,TraitConst,MaybeConstDefault,TraitType,MaybeUnsafe,MaybeDefaultMaybeUnsafe,TraitMethod,TypeMethod,Method,ImplMethod(ItemKind),
ItemImpl(ItemKind),MaybeImplItems(Vec<ItemKind>),ImplItems(Vec<ItemKind>),ImplItem(ItemKind),MaybeDefault,ImplConst,ImplType,ItemFn(ItemKind),ItemUnsafeFn,FnDecl(Vec<(PatKind,TyLf)>,Option<TyKind>),FnDeclWithSelf(bool,bool,bool,Option<TyLf>,Vec<(PatKind,TyLf)>,Option<TyKind>),
FnDeclWithSelfAllowAnonParams,FnParams(Vec<(PatKind,TyLf)>),FnAnonParams,FnParamsWithSelf(bool,bool,bool,Option<TyLf>,Vec<(PatKind,TyLf)>),FnAnonParamsWithSelf,MaybeParams(Vec<(PatKind,TyLf)>),Params(Vec<(PatKind,TyLf)>),Param(PatKind,TyLf),InferrableParams(Vec<(PatKind,Option<TyLf>)>),
InferrableParam(PatKind,Option<TyLf>),MaybeCommaParams(Vec<(PatKind,TyLf)>),MaybeCommaAnonParams,MaybeAnonParams,AnonParams,AnonParam,AnonParamsAllowVariadicTail,NamedArg,RetTy(Option<TyKind>),
GenericParams(Vec<String>,Vec<String>),MaybeWhereClause,WhereClause,WherePredicates,WherePredicate,MaybeForLifetimes,TyParams(Vec<String>),PathNoTypesAllowed(PathNKind),
PathGenericArgsWithoutColons(PathWKind),GenericArgs(Vec<TyLf>),GenericValues(Vec<TyLf>),MaybeTySumsAndOrBindings(Vec<TyLf>),MaybeBindings,Pat(PatKind),PatsOr(PatKind),
BindingMode(BindKind),LitOrPath(PathKind),PatField,PatFields,PatStruct,PatTup(Vec<PatKind>),PatTupElts(Vec<PatKind>),PatVec,PatVecElts,
Ty(TyKind),TyPrim(TyKind),TyBareFn,TyFnDecl,TyClosure,ForInType,ForInTypeSuffix,MaybeMut(bool),MaybeMutOrConst,
TyQualifiedPathAndGenericValues,TyQualifiedPath,MaybeTySums(Vec<TyLf>),TySums(Vec<TyLf>),TySum(TyLf),TySumElt(TyLf),
TyPrimSum(TyLf),TyPrimSumElt(TyLf),MaybeTyParamBounds,TyParamBounds,Boundseq,Polybound,Bindings,Binding,TyParam(String),MaybeBounds,Bounds,Bound,
MaybeLTBounds,LTBounds,MaybeTyDefault,MaybeLifetimes,Lifetimes(Vec<String>),LifetimeAndBounds(String),Lifetime(String),TraitRef(PathWKind),InnerAttrsAndBlock(Vec<StmtKind>,Option<ExprKind>),
Block(Vec<StmtKind>,Option<ExprKind>),MaybeStmts(Vec<StmtKind>,Option<ExprKind>),Stmts(Vec<StmtKind>),Stmt(StmtKind),
MaybeExprs(Vec<ExprKind>),MaybeExpr(Option<ExprKind>),Exprs(Vec<ExprKind>),PathExpr(PathKind),PathGenericArgsWithColons(PathKind),
MacroExpr(Rc<Token>,Option<Rc<Token>>,Rc<Token>),NonblockExpr(ExprKind),Expr(ExprKind),ExprNostruct(ExprKind),NonblockPrefixExprNostruct(ExprKind),NonblockPrefixExpr(ExprKind),
ExprQualifiedPath,MaybeQPathParams,MaybeAsTraitRef,LambdaExpr(ExprKind),LambdaExprNoFirstBar(ExprKind),LambdaExprNostruct(ExprKind),LambdaExprNostructNoFirstBar(ExprKind),
VecExpr,StructExprFields(Vec<(String,Option<ExprKind>)>),MaybeFieldInits(Vec<(String,Option<ExprKind>)>),FieldInits(Vec<(String,Option<ExprKind>)>),FieldInit(String,Option<ExprKind>),DefaultFieldInit,BlockExpr(Rc<Token>),FullBlockExpr(Rc<Token>),
BlockExprDot,ExprMatch(ExprKind,Vec<Rc<Token>>),MatchClauses(Vec<Rc<Token>>),MatchClause(Vec<AttrKind>,PatKind,Rc<Token>),
NonblockMatchClause(Vec<AttrKind>,PatKind,Rc<Token>),BlockMatchClause(Vec<AttrKind>,PatKind,Rc<Token>),
MaybeGuard,ExprIf(ExprKind,Rc<Token>,Option<Rc<Token>>),ExprIfLet(PatKind,ExprKind,Rc<Token>,Option<Rc<Token>>),BlockOrIf(Rc<Token>),ExprWhile(ExprKind,Rc<Token>),ExprWhileLet,
ExprLoop,ExprFor(PatKind,ExprKind,Rc<Token>),MaybeLabel,Let(StmtKind),Lit(Rc<Token>),Str(String),MaybeIdent,Ident(String),UnpairedToken(Rc<Token>),TokenTrees(Vec<Rc<Token>>),
TokenTree(Rc<Token>),DelimitedTokenTrees(Rc<Token>),ParensDelimitedTokenTrees(Vec<Rc<Token>>),
BracesDelimitedTokenTrees(Vec<Rc<Token>>),BracketsDelimitedTokenTrees(Vec<Rc<Token>>),MaybeSpace,
ItemTerminal(ItemKind),MaybeTerminalItems(Vec<ItemKind>),TerminalItems(Vec<ItemKind>),
TerminalItem(ItemKind),ItemNonterminal(ItemKind),}
impl Default for Token { fn default()->Self{Token::DummyStart} }


impl Display for PatKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&PatKind::Fixme => write!(f," FIXME "),
			&PatKind::Underscore => write!(f,"_"),
			&PatKind::Ref(ref kind) => write!(f,"& {}",kind),
			&PatKind::RefMut(ref kind) => write!(f,"&mut {}",kind),
			&PatKind::Void => write!(f,"()"),
			&PatKind::Tuple(ref tuple) => write!(f,"({})",tuple.iter().map(|p|p.to_string()).collect::<Vec<String>>().join(",")),
			&PatKind::Path(ref token) => write!(f,"{}",token),
			&PatKind::EnumEmpty(ref name) => write!(f,"{}",name),
			&PatKind::Enum(ref name, ref tuple) => write!(f,"{}({})",name,tuple.iter().map(|p|p.to_string()).collect::<Vec<String>>().join(",")),
			&PatKind::BindedIdent(BindKind::Ref, ref string) => write!(f,"ref {}",string),
			&PatKind::BindedIdent(BindKind::RefMut, ref string) => write!(f,"ref mut {}",string),
			&PatKind::BindedIdent(BindKind::Mut, ref string) => write!(f,"mut {}",string),
		}
	}
}

impl Display for TyKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&TyKind::Fixme => write!(f," FIXME "),
			&TyKind::Underscore => write!(f,"_"),
			&TyKind::Ref(ref kind) => write!(f,"& {}",kind),
			&TyKind::RefMut(ref kind) => write!(f,"&mut {}",kind),
			&TyKind::RefLifetime(ref lifetime, true ,ref kind) => write!(f,"&{} mut {}",lifetime,kind),
			&TyKind::RefLifetime(ref lifetime, false ,ref kind) => write!(f,"&{} {}",lifetime,kind),
			&TyKind::Void => write!(f,"()"),
			&TyKind::Path(ref path) => write!(f,"{}",path),
			&TyKind::Tuple(ref list) => write!(f,"({})",list.iter().map(|t|t.to_string()).collect::<Vec<String>>().join(",")),
		}
	}
}

impl Display for ExprKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&ExprKind::Fixme => write!(f," FIXME "),
			&ExprKind::Single(ref token) => write!(f,"{}",token),
			&ExprKind::Member(ref kind, ref path) => write!(f,"{}.{}",kind,path),
			&ExprKind::Index(ref object, None) => write!(f,"{}[]",object),
			&ExprKind::Index(ref object, Some(ref index)) => write!(f,"{}[{}]",object,index),
			&ExprKind::Call(ref function, ref arguments) => write!(f,"{}({})",function,arguments.iter().map(|x| x.to_string() ).collect::<Vec<String>>().join(",")),
			&ExprKind::Parentheses(ref list) => write!(f,"({})",list.iter().map(|x| x.to_string() ).collect::<Vec<String>>().join(",")),
			&ExprKind::Infix(ref left,ref symbol,ref right) => write!(f,"{} {} {}",left,symbol,right),
			&ExprKind::Ref(ref expr) => write!(f,"&{}",expr),
			&ExprKind::RefMut(ref expr) => write!(f,"&mut {}",expr),
			&ExprKind::Prefix(ref symbol, ref expr) => write!(f,"{} {}",symbol,expr),
			&ExprKind::Lambda(ref args, ref ot, ref expr) => write!(f,"|{}|{}{}",args.iter().map(|&(ref pat,ref opt)|match opt{
				&None => pat.to_string(),
				&Some(ref t) => format!("{}:{}",pat,t),
			}).collect::<Vec<String>>().join(","),match ot { &None=>String::from(""), &Some(ref t)=>t.to_string(), },expr),
			&ExprKind::Struct(ref path, ref initializations) => write!(f,"{}{{{}}}",path,initializations.iter().map(|&(ref s,ref oe)|match oe{
				&None => format!("{},",s),
				&Some(ref e) => format!("{}:{},",s,e),
			}).collect::<Vec<String>>().join("\n")),
			&ExprKind::Range(Some(ref left),None) => write!(f,"{}..",left),
			&ExprKind::Range(Some(ref left),Some(ref right)) => write!(f,"{}..{}",left,right),
			&ExprKind::Range(None,Some(ref right)) => write!(f,"..{}",right),
			&ExprKind::Range(None,None) => write!(f,".."),
			&ExprKind::Return(None) => write!(f,"return"),
			&ExprKind::Return(Some(ref expr)) => write!(f,"return {}",expr),
			&ExprKind::Break(None) => write!(f,"break"),
			&ExprKind::Break(Some(ref string)) => write!(f,"break {}",string),
		}
	}
}

impl Display for StmtKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&StmtKind::Let(ref pattern,ref option_type,ref option_expr) =>
			{
				write!(f,"let {}",pattern).unwrap();
				if let &Some(ref t)=option_type
				{
					write!(f,":{}",t).unwrap();
				}
				if let &Some(ref e)=option_expr
				{
					write!(f,"={}",e).unwrap();
				}
				write!(f,";")
			},
			&StmtKind::Item(ref attrs, ref token) => write!(f,"{}",token),
			&StmtKind::Block(ref attrs, ref token) => write!(f,"{}",token),
			&StmtKind::Expr(ref attrs, ref expr) => write!(f,"{};",expr),
			&StmtKind::Empty => write!(f,";"),
		}
	}
}

impl AttrKind
{
	fn simple_to_string(&self)->String
	{
		match self
		{
			&AttrKind::Documentation(ref string) => string.clone(),
			&AttrKind::Flag(ref string) => string.clone(),
			&AttrKind::Value(ref string,ref token) => format!("{}={}",string,token),
			&AttrKind::Sequence(ref string, ref attributes) => format!("{}({})",string,attributes.iter().map(|x|x.simple_to_string()).collect::<Vec<String>>().join(",")),
		}
	}
}
impl Display for AttrKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&AttrKind::Documentation(ref string) => write!(f,"{}",string),
			&AttrKind::Flag(ref string) => write!(f,"#[{}]",string),
			&AttrKind::Value(ref string,ref token) => write!(f,"#[{}={}]",string,token),
			&AttrKind::Sequence(ref string, ref attributes) => write!(f,"#[{}({})]",string,attributes.iter().map(|x|x.simple_to_string()).collect::<Vec<String>>().join(",")),
		}
	}
}

impl Display for PathKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&PathKind::Fixme => write!(f,"::fixme::"),
			&PathKind::Ident(ref string) => write!(f,"{}",string),
			&PathKind::Super => write!(f,"super"),
			&PathKind::Absolute(ref path) => write!(f,"::{}",path),
			&PathKind::FromSelf(ref path) => write!(f,"self::{}",path),
			&PathKind::StepIdent(ref path, ref string) => write!(f,"{}::{}",path,string),
			&PathKind::StepSuper(ref path) => write!(f,"{}::super",path),
			&PathKind::GenericArgs(ref path, ref ga) => write!(f,"{}::<{}>",path,ga.iter().map(|x|x.to_string()).collect::<Vec<String>>().join(",")),
			&PathKind::Literal(ref token) => write!(f,"{}",token),
		}
	}
}

impl Display for PathWKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&PathWKind::Fixme => write!(f,"::fixme::"),
			&PathWKind::Ident(ref string) => write!(f,"{}",string),
			&PathWKind::IdentGeneric(ref string,ref gens) => write!(f,"{}<{}>",string,gens.iter().map(|g|g.to_string()).collect::<Vec<String>>().join(",")),
			&PathWKind::Function(ref string,ref arguments,ref return_type) => write!(f,"{}({}){}",string,arguments.iter().map(|x|x.to_string()).collect::<Vec<String>>().join(","),return_type),
			&PathWKind::StepIdent(ref path, ref string) => write!(f,"{}::{}",path,string),
			&PathWKind::StepIdentGeneric(ref path, ref string, ref gens) => write!(f,"{}::{}<{}>",path,string,gens.iter().map(|g|g.to_string()).collect::<Vec<String>>().join(",")),
			&PathWKind::StepFunction(ref path,ref string,ref arguments,ref return_type) => write!(f,"{}::{}({}){}",path,string,arguments.iter().map(|x|x.to_string()).collect::<Vec<String>>().join(","),return_type),
		}
	}
}

impl Display for PathNKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&PathNKind::Fixme => write!(f,"::fixme::"),
			&PathNKind::Ident(ref string) => write!(f,"{}",string),
			&PathNKind::AbsoluteIdent(ref string) => write!(f,"::{}",string),
			&PathNKind::FromSelf => write!(f,"self"),
			&PathNKind::AbsoluteSelf => write!(f,"::self"),
			&PathNKind::Super => write!(f,"super"),
			&PathNKind::AbsoluteSuper => write!(f,"::super"),
			&PathNKind::Step(ref path,ref string) => write!(f,"{}::{}",path,string),
		}
	}
}

impl Display for ViewKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&ViewKind::Fixme => write!(f,"view fixme;"),
			&ViewKind::Path(ref path,None) => write!(f,"use {};",path),
			&ViewKind::Path(ref path,Some(ref string)) => write!(f,"use {} as {};",path,string),
			&ViewKind::All(None) => write!(f,"use *;"),
			&ViewKind::All(Some(ref path)) => write!(f,"use {}::*;",path),
			&ViewKind::Selection(None,ref list) => write!(f,"use {{{}}};",list.join(",")),
			&ViewKind::Selection(Some(ref path),ref list) => write!(f,"use {}::{{{}}};",path,list.join(",")),
			&ViewKind::ExternCrate(ref name, None) => write!(f,"extern crate {};",name),
			&ViewKind::ExternCrate(ref name, Some(ref string_as)) => write!(f,"extern crate {} as {};",name,string_as),
		}
	}
}

impl Display for ItemKind
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&ItemKind::Fixme => write!(f,"fixme {{ }}"),
			&ItemKind::Macro(ref name, ref subname, ref token) => write!(f,"{}!{};",name,token),//FIXME
			&ItemKind::FN(ref name, ref lifetimes, ref gp, ref params, ref oret, ref block_stmts, ref block_expr) =>
			{
				//write!(f,"fn fixme() {{ }}"),
				write!(f,"fn {}",name).unwrap();
				if lifetimes.len()>0 || gp.len()>0
				{
					//write!(f,"<{}>",gp.join(",")).unwrap();
					write!(f,"<{}>",lifetimes.iter().chain(gp.iter()).map(|x|x.clone()).collect::<Vec<String>>().join(",")).unwrap();
				}
				write!(f,"({})",params.iter().map(|&(ref p,ref t)| format!("{}:{}",p,t) ).collect::<Vec<String>>().join(",")).unwrap();
				if let &Some(ref ret)=oret
				{
					write!(f,"->{}",ret).unwrap();
				}
				writeln!(f,"{{").unwrap();
				for stmt in block_stmts
				{
					writeln!(f,"{}",stmt).unwrap();
				}
				if let &Some(ref e)=block_expr
				{
					write!(f,"{}",e).unwrap();
				}
				writeln!(f,"}}")
			},
			&ItemKind::Method(ref name, ref lifetimes, ref gp, has_self, self_has_ref, self_has_mut, ref o_self_type, ref params, ref oret, ref block_stmts, ref block_expr) =>
			{
				//write!(f,"fn fixme() {{ }}"),
				write!(f,"fn {}",name).unwrap();
				if lifetimes.len()>0 || gp.len()>0
				{
					//write!(f,"<{}>",gp.join(",")).unwrap();
					write!(f,"<{}>",lifetimes.iter().chain(gp.iter()).map(|x|x.clone()).collect::<Vec<String>>().join(",")).unwrap();
				}
				write!(f,"(").unwrap();
				if has_self
				{
					if self_has_ref
					{
						write!(f,"&").unwrap();
					}
					if self_has_mut
					{
						write!(f,"mut ").unwrap();
					}
					write!(f,"self").unwrap();
					if let &Some(ref t)=o_self_type
					{
						write!(f,":{}",t).unwrap();
					}
					if params.len()>0
					{
						write!(f,",").unwrap();
					}
				}
				write!(f,"{})",params.iter().map(|&(ref p,ref t)| format!("{}:{}",p,t) ).collect::<Vec<String>>().join(",")).unwrap();
				if let &Some(ref ret)=oret
				{
					write!(f,"->{}",ret).unwrap();
				}
				writeln!(f,"{{").unwrap();
				for stmt in block_stmts
				{
					writeln!(f,"{}",stmt).unwrap();
				}
				if let &Some(ref e)=block_expr
				{
					write!(f,"{}",e).unwrap();
				}
				writeln!(f,"}}")
			},
			&ItemKind::Terminal(_,_,_) => panic!("Should not be printing this"),
			&ItemKind::Nonterminal(_,_,_) => panic!("Should not be printing this"),
			&ItemKind::View(ref view) => write!(f,"{}",view),
			&ItemKind::Enum(ref id, ref lifetimes, ref params, ref defs) =>
			{
				write!(f,"enum {}",id).unwrap();
				if lifetimes.len()>0 || params.len()>0
				{
					//write!(f,"({})",params.join(",")).unwrap();
					write!(f,"<{}>",lifetimes.iter().chain(params.iter()).map(|x|x.clone()).collect::<Vec<String>>().join(",")).unwrap();
				}
				writeln!(f,"{{").unwrap();
				for &(ref name,ref tys) in defs
				{
					write!(f,"{}",name).unwrap();
					if tys.len()>0
					{
						write!(f,"({})",tys.iter().map(|t|t.to_string()).collect::<Vec<String>>().join(",")).unwrap();
					}
					writeln!(f,",").unwrap();
				}
				writeln!(f,"}}")
			},
			&ItemKind::Impl(ref lifetimes, ref gp, ref otrait, ref t, ref items) =>
			{
				write!(f,"impl").unwrap();
				if lifetimes.len()>0 || gp.len()>0
				{
					//write!(f,"<{}>",gp.join(",")).unwrap();
					write!(f,"<{}>",lifetimes.iter().chain(gp.iter()).map(|x|x.clone()).collect::<Vec<String>>().join(",")).unwrap();
				}
				if let &Some(ref tr)=otrait
				{
					writeln!(f," {} for {} {{",tr,t).unwrap();
				}
				else
				{
					writeln!(f," {} {{",t).unwrap();
				}
				for item in items
				{
					writeln!(f,"{}",item).unwrap();
				}
				writeln!(f,"}}")
			},
			&ItemKind::Struct(ref name, ref lifetimes, ref gp, ref fields) =>
			{
				write!(f,"struct {}",name).unwrap();
				if lifetimes.len()>0 || gp.len()>0
				{
					//write!(f,"<{}>",gp.join(",")).unwrap();
					write!(f,"<{}>",lifetimes.iter().chain(gp.iter()).map(|x|x.clone()).collect::<Vec<String>>().join(",")).unwrap();
				}
				writeln!(f,"{{").unwrap();
				for &(ref name,ref ty) in fields
				{
					writeln!(f,"{}:{},",name,ty).unwrap();
				}
				writeln!(f,"}}")
			},
		}
	}
}

impl Display for TyLf
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&TyLf::Type(ref t) => write!(f,"{}",t),
			&TyLf::Lifetime(ref string) => write!(f,"{}",string),
		}
	}
}

impl Display for Token
{
	fn fmt(&self, f:&mut Formatter) -> fmt::Result
	{
		match self
		{
			&Token::TySum(ref kind) => write!(f,"{}",kind),
			&Token::Pat(ref kind) => write!(f,"{}",kind),
			&Token::LitOrPath(ref string) => write!(f,"{}",string),
			&Token::NonblockExpr(ref expr) => write!(f,"{}",expr),
			&Token::PathExpr(ref string) => write!(f,"{}",string),
			&Token::Block(ref stmts, None) => write!(f,"{{{}}}", stmts.iter().map(|s| s.to_string() ).collect::<Vec<String>>().join("\n") ),
			&Token::Block(ref stmts, Some(ref expr)) => write!(f,"{{{} {}}}", stmts.iter().map(|s| s.to_string() ).collect::<Vec<String>>().join("\n") , expr),
			&Token::Equal => write!(f,"="),
			&Token::Lit(ref token) => write!(f,"{}",token),
			&Token::LitInteger(x) => write!(f,"{}",x),
			&Token::LitStr(ref string) => write!(f,"{}",string),
			&Token::LitChar(c) => match c
			{
				'\'' => write!(f,"'\\\''"),
				'\\' => write!(f,"'\\\\'"),
				_ => write!(f,"'{}'",c),
			},
			&Token::Str(ref string) => write!(f,"{}",string),
			&Token::BlockExpr(ref token) => write!(f,"{}",token),
			&Token::ExprMatch(ref expr,ref clauses) => write!(f,"match {} {{ {} }}",expr,clauses.iter().map(|c|c.to_string()).collect::<Vec<String>>().join("\n")),
			&Token::ExprIf(ref expr, ref block, None) => write!(f,"if {} {}",expr,block),
			&Token::ExprIf(ref expr, ref block, Some(ref else_block)) => write!(f,"if {} {} else {}",expr,block,else_block),
			&Token::ExprIfLet(ref pattern, ref expr, ref block, None) => write!(f,"if let {}={} {}",pattern,expr,block),
			&Token::ExprIfLet(ref pattern, ref expr, ref block, Some(ref else_block)) => write!(f,"if let {}={} {} else {}",pattern,expr,block,else_block),
			&Token::ExprFor(ref pattern, ref expr, ref block) => write!(f,"for {} in {} {}",pattern,expr,block),
			&Token::ExprWhile(ref expr, ref block) => write!(f,"while {} {}",expr,block),
			&Token::True => write!(f,"true"),
			&Token::False => write!(f,"false"),
			&Token::Ref => write!(f,"ref"),
			&Token::For => write!(f,"for"),
			&Token::Match => write!(f,"match"),
			&Token::If => write!(f,"if"),
			&Token::Else => write!(f,"else"),
			&Token::MacroExpr(ref token,None,ref trees) => write!(f,"{}!{}",token,trees),
			&Token::DelimitedTokenTrees(ref trees) => write!(f,"{}",trees),
			&Token::BracketsDelimitedTokenTrees(ref trees) => write!(f,"[{}]",trees.iter().map(|t|t.to_string()).collect::<Vec<String>>().join(" ")),
			&Token::ParensDelimitedTokenTrees(ref trees) => write!(f,"({})",trees.iter().map(|t|t.to_string()).collect::<Vec<String>>().join(" ")),
			&Token::BracesDelimitedTokenTrees(ref trees) => write!(f,"{{{}}}",trees.iter().map(|t|t.to_string()).collect::<Vec<String>>().join(" ")),
			&Token::LiteralIdent(ref string) => write!(f,"{}",string),
			&Token::Dot => write!(f,"."),
			&Token::Comma => write!(f,","),
			&Token::ModSep => write!(f,"::"),
			&Token::Vertical => write!(f,"|"),
			&Token::Ampersand => write!(f,"&"),
			&Token::Plus => write!(f,"+"),
			&Token::Minus => write!(f,"-"),
			&Token::Star => write!(f,"*"),
			&Token::Bang => write!(f,"!"),
			&Token::LT => write!(f,"<"),
			&Token::GT => write!(f,">"),
			&Token::NE => write!(f,"!="),
			&Token::EqualEqual => write!(f,"=="),
			&Token::AndAnd => write!(f,"&&"),
			&Token::OrOr => write!(f,"||"),
			&Token::PlusEqual => write!(f,"+="),
			&Token::FatArrow => write!(f,"=>"),
			&Token::DotDot => write!(f,".."),
			&Token::MatchClause(ref attributes,ref pattern, ref token) => write!(f,"{} => {},",pattern,token),//FIXME
			&Token::PatTup(ref patterns) => write!(f,"{}",patterns.iter().map(|p|p.to_string()).collect::<Vec<String>>().join(" ")),
			&Token::LittleSelf => write!(f,"self"),
			_ => panic!("panic displaying {:?}",self),
			//_ => Err(fmt::Error),
		}
	}
}




struct ParsingTables { }
impl ParsingTablesTrait<Token> for ParsingTables {
fn initial()->usize { 105 }
fn match_some(parser: &mut Parser<Token,Self>) -> Option<(usize,Token)> { let source=&parser.source[parser.source_index..];
match { match parser.re("static",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Static)), };
match { match parser.re("mut",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Mut)), };
match { match parser.re("const",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Const)), };
match { match parser.re("crate",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Crate)), };
match { match parser.re("extern",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Extern)), };
match { match parser.re("as ",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::As)), };
match { match parser.re("struct",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Struct)), };
match { match parser.re("enum ",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Enum)), };
match { match parser.re("union",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Union)), };
match { match parser.re("mod",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Mod)), };
match { match parser.re("unsafe",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Unsafe)), };
match { match parser.re("fn ",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::FN)), };
match { match parser.re("pub",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Pub)), };
match { match parser.re("self",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::LittleSelf)), };
match { match parser.re("type ",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Type)), };
match { match parser.re("for ",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::For)), };
match { match parser.re("trait",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Trait)), };
match { match parser.re("default",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::DEFAULT)), };
match { match parser.re("impl",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Impl)), };
match { match parser.re("where",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Where)), };
match { match parser.re("super",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Super)), };
match { match parser.re("box",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::BOX)), };
match { match parser.re("ref",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Ref)), };
match { match parser.re("typeof",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Typeof)), };
match { match parser.re("'static",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::StaticLifetime)), };
match { match parser.re("continue",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Continue)), };
match { match parser.re("return",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Return)), };
match { match parser.re("break",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Break)), };
match { match parser.re("yield",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Yield)), };
match { match parser.re("move",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Move)), };
match { match parser.re("match",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Match)), };
match { match parser.re("if",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::If)), };
match { match parser.re("else",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Else)), };
match { match parser.re("let",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::LiteralLet)), };
match { match parser.re("while",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::While)), };
match { match parser.re("loop",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Loop)), };
match { match parser.re("in ",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::In)), };
match { match parser.re("true",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::True)), };
match { match parser.re("false",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::False)), };
match { match parser.re("catch",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Catch)), };
match { match parser.re("use",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Use)), };
match { match parser.re("terminal",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Terminal)), };
match { match parser.re("nonterminal",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Nonterminal)), };
//PUT HERE THE MATCH WITH ShebangLine,
//PUT HERE THE MATCH WITH LitInteger,
		match
		{
			match parser.re("[0-9]+", source)
			{
				None => None,
				Some((size,string)) => Some((size,string.parse::<usize>().unwrap())),
			}
		}
		{
			None => (),
			Some((size,result)) => return Some((size,Token::LitInteger(result))),
		};
//PUT HERE THE MATCH WITH LiteralLifetime,
		match
		{
			match parser.re("'[a-zA-Z_]+", source)
			{
				None => None,
				Some((size,string)) => Some((size,string)),
			}
		}
		{
			None => (),
			Some((size,result)) => return Some((size,Token::LiteralLifetime(result))),
		};
//PUT HERE THE MATCH WITH LitByte,
//PUT HERE THE MATCH WITH LitChar,
		match
		{
			let mut characters=source.chars();
			if characters.next()==Some('\'')
			{
				let mut c=characters.next().unwrap();
				let mut size=3;
				if c=='\\'
				{
					c=characters.next().unwrap();
					size=4;
				}
				if characters.next().unwrap()=='\''
				{
					Some((size,c))
				}
				else
				{
					None
				}
			}
			else
			{
				None
			}
		}
		{
			None => (),
			Some((size,result)) => return Some((size,Token::LitChar(result))),
		};
//PUT HERE THE MATCH WITH LitFloat,
//PUT HERE THE MATCH WITH LitStr,
		match
		{
			let mut ret=None;
			let mut characters=source.chars();
			if characters.next()!=Some('"')
			{
			}
			else
			{
				let mut size=1;
				let mut r=String::from("\"");
				loop
				{
					match characters.next()
					{
						None => break,
						Some('"') =>
						{
							ret=Some((size+1,r+&"\""));
							break;
						},
						Some('\\') =>
						{
							match characters.next()
							{
								None => break,
								//Some(c) => r+='\\'+c,
								Some(c) =>
								{
									r.push('\\');
									r.push(c);
								}
							};
							size+=2;
						},
						Some(c) =>
						{
							//r+=&String::from(c);
							r.push(c);
							size+=1;
						},
					};
				}
			}
			ret
		}
		{
			None => (),
			Some((size,result)) => return Some((size,Token::LitStr(result))),
		};
//PUT HERE THE MATCH WITH LitStrRaw,
//PUT HERE THE MATCH WITH LitByteStr,
//PUT HERE THE MATCH WITH LitByteStrRaw,
//PUT HERE THE MATCH WITH NoSpace,
match { match parser.re("\\\\![^\n]*\n",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::InnerDocComment)), };
match { match parser.re("\\\\\\[^\n]*\n",source) { None => None, Some((size,string)) => Some((size,string)) } }
{ None => (), Some((size,result)) => return Some((size,Token::OuterDocComment(result))), };
match { match parser.re("[a-zA-Z\\x80-\\xff_][a-zA-Z0-9\\x80-\\xff_]*",source) { None => None, Some((size,string)) => Some((size,string)) } }
{ None => (), Some((size,result)) => return Some((size,Token::LiteralIdent(result))), };
match { match parser.re("#!",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Shebang)), };
match { match parser.re("#",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::NumberSign)), };
match { match parser.re("=>",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::FatArrow)), };
match { match parser.re("==",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::EqualEqual)), };
match { match parser.re("!=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::NE)), };
match { match parser.re("=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Equal)), };
match { match parser.re("<-",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::LArrow)), };
match { match parser.re("->",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::RArrow)), };
match { match parser.re("<=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::LE)), };
match { match parser.re(">=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::GE)), };
match { match parser.re("-=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::MinusEqual)), };
match { match parser.re("&=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::AndEqual)), };
match { match parser.re("\\|=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::OrEqual)), };
match { match parser.re("\\+=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::PlusEqual)), };
match { match parser.re("\\*=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::StarEqual)), };
match { match parser.re("/=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::SlashEqual)), };
match { match parser.re("\\^=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::CaretEqual)), };
match { match parser.re("%=",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::PercentEqual)), };
match { match parser.re("_",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Underscore)), };
match { match parser.re("\\|\\|",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::OrOr)), };
match { match parser.re("\\|",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Vertical)), };
match { match parser.re(",",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Comma)), };
match { match parser.re("&&",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::AndAnd)), };
match { match parser.re("&",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Ampersand)), };
match { match parser.re("\\.\\.\\.",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::DotDotDot)), };
match { match parser.re("\\.\\.",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::DotDot)), };
match { match parser.re("\\.",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Dot)), };
match { match parser.re("::",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::ModSep)), };
match { match parser.re(":",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Colon)), };
match { match parser.re("\\^",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Caret)), };
match { match parser.re("%",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Percent)), };
match { match parser.re(";",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Semicolon)), };
match { match parser.re("!",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Bang)), };
match { match parser.re("@",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::At)), };
match { match parser.re("\\*",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Star)), };
match { match parser.re("\\?",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::QuestionMark)), };
match { match parser.re("\\[",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::LBracket)), };
match { match parser.re("\\]",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::RBracket)), };
match { match parser.re("\\(",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::LPar)), };
match { match parser.re("\\)",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::RPar)), };
match { match parser.re("\\{",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::LBrace)), };
match { match parser.re("\\}",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::RBrace)), };
match { match parser.re("<",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::LT)), };
match { match parser.re(">",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::GT)), };
match { match parser.re("\\+",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Plus)), };
match { match parser.re("-",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Minus)), };
match
{
	match parser.re("\\s+|\n|\\\\[^\n]*\n", source)
	{
		None => None,
		Some((size,_string)) => Some((size,())),
	}
}
{
	None => (),
	Some((size,_result)) => return Some((size,Token::DummyStart)),
};
match { match parser.re("/",source) { None => None, Some((size,_string)) => Some((size,())) } }
{ None => (), Some((size,_result)) => return Some((size,Token::Slash)), };
None
}//match_some
fn predict(parser:&mut Parser<Token,Self>,index:usize,state_index:usize,token:usize) { match token {
105 => {
parser.sets[index].predict(State{rule: 1 ,left: 105 ,right:vec![ 106,108,115 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 2 ,left: 105 ,right:vec![ 106,115 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
106 => {
parser.sets[index].predict(State{rule: 3 ,left: 106 ,right:vec![ 44 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 4 ,left: 106 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
107 => {
parser.sets[index].predict(State{rule: 5 ,left: 107 ,right:vec![ 108 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 6 ,left: 107 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
108 => {
parser.sets[index].predict(State{rule: 7 ,left: 108 ,right:vec![ 109 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 8 ,left: 108 ,right:vec![ 108,109 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
109 => {
parser.sets[index].predict(State{rule: 9 ,left: 109 ,right:vec![ 58,95,113,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 10 ,left: 109 ,right:vec![ 55 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
110 => {
parser.sets[index].predict(State{rule: 11 ,left: 110 ,right:vec![ 111 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 12 ,left: 110 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
111 => {
parser.sets[index].predict(State{rule: 13 ,left: 111 ,right:vec![ 112 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 14 ,left: 111 ,right:vec![ 111,112 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
112 => {
parser.sets[index].predict(State{rule: 15 ,left: 112 ,right:vec![ 59,95,113,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 16 ,left: 112 ,right:vec![ 56 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
113 => {
parser.sets[index].predict(State{rule: 17 ,left: 113 ,right:vec![ 309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 18 ,left: 113 ,right:vec![ 309,63,306 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 19 ,left: 113 ,right:vec![ 309,97,114,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 20 ,left: 113 ,right:vec![ 309,97,114,79,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
114 => {
parser.sets[index].predict(State{rule: 21 ,left: 114 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 22 ,left: 114 ,right:vec![ 113 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 23 ,left: 114 ,right:vec![ 114,79,113 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
115 => {
parser.sets[index].predict(State{rule: 24 ,left: 115 ,right:vec![ 116 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 25 ,left: 115 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
116 => {
parser.sets[index].predict(State{rule: 26 ,left: 116 ,right:vec![ 118 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 27 ,left: 116 ,right:vec![ 116,118 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
117 => {
parser.sets[index].predict(State{rule: 28 ,left: 117 ,right:vec![ 110,153 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
118 => {
parser.sets[index].predict(State{rule: 29 ,left: 118 ,right:vec![ 117,119 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
119 => {
parser.sets[index].predict(State{rule: 30 ,left: 119 ,right:vec![ 120 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 31 ,left: 119 ,right:vec![ 123 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
120 => {
parser.sets[index].predict(State{rule: 32 ,left: 120 ,right:vec![ 121 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 33 ,left: 120 ,right:vec![ 122 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 34 ,left: 120 ,right:vec![ 156 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 35 ,left: 120 ,right:vec![ 128 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 36 ,left: 120 ,right:vec![ 124 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
121 => {
parser.sets[index].predict(State{rule: 37 ,left: 121 ,right:vec![ 1,309,86,224,63,271,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 38 ,left: 121 ,right:vec![ 1,2,309,86,224,63,271,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
122 => {
parser.sets[index].predict(State{rule: 39 ,left: 122 ,right:vec![ 3,309,86,224,63,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
123 => {
parser.sets[index].predict(State{rule: 40 ,left: 123 ,right:vec![ 267,91,308,314,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 41 ,left: 123 ,right:vec![ 267,91,308,315 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 42 ,left: 123 ,right:vec![ 267,91,308,316,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
124 => {
parser.sets[index].predict(State{rule: 43 ,left: 124 ,right:vec![ 126 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 44 ,left: 124 ,right:vec![ 125 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 45 ,left: 124 ,right:vec![ 5,4,309,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 46 ,left: 124 ,right:vec![ 5,4,309,6,309,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
125 => {
parser.sets[index].predict(State{rule: 47 ,left: 125 ,right:vec![ 5,145,178 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
126 => {
parser.sets[index].predict(State{rule: 48 ,left: 126 ,right:vec![ 41,127,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
127 => {
parser.sets[index].predict(State{rule: 49 ,left: 127 ,right:vec![ 207 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 50 ,left: 127 ,right:vec![ 207,85,99,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 51 ,left: 127 ,right:vec![ 85,99,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 52 ,left: 127 ,right:vec![ 207,85,99,154,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 53 ,left: 127 ,right:vec![ 85,99,154,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 54 ,left: 127 ,right:vec![ 207,85,99,154,79,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 55 ,left: 127 ,right:vec![ 85,99,154,79,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 56 ,left: 127 ,right:vec![ 207,85,93 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 57 ,left: 127 ,right:vec![ 85,93 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 58 ,left: 127 ,right:vec![ 93 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 59 ,left: 127 ,right:vec![ 99,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 60 ,left: 127 ,right:vec![ 99,154,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 61 ,left: 127 ,right:vec![ 99,154,79,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 62 ,left: 127 ,right:vec![ 207,6,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
128 => {
parser.sets[index].predict(State{rule: 63 ,left: 128 ,right:vec![ 178 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 64 ,left: 128 ,right:vec![ 179 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 65 ,left: 128 ,right:vec![ 143 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 66 ,left: 128 ,right:vec![ 144 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 67 ,left: 128 ,right:vec![ 131 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 68 ,left: 128 ,right:vec![ 138 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 69 ,left: 128 ,right:vec![ 142 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 70 ,left: 128 ,right:vec![ 158 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 71 ,left: 128 ,right:vec![ 171 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 72 ,left: 128 ,right:vec![ 318 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 73 ,left: 128 ,right:vec![ 322 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
129 => {
parser.sets[index].predict(State{rule: 74 ,left: 129 ,right:vec![ 86,237 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 75 ,left: 129 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
130 => {
parser.sets[index].predict(State{rule: 76 ,left: 130 ,right:vec![ 63,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 77 ,left: 130 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
131 => {
parser.sets[index].predict(State{rule: 78 ,left: 131 ,right:vec![ 7,309,200,201,132 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 79 ,left: 131 ,right:vec![ 7,309,200,133,201,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 80 ,left: 131 ,right:vec![ 7,309,200,201,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
132 => {
parser.sets[index].predict(State{rule: 81 ,left: 132 ,right:vec![ 99,134,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 82 ,left: 132 ,right:vec![ 99,134,100,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
133 => {
parser.sets[index].predict(State{rule: 83 ,left: 133 ,right:vec![ 97,136,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 84 ,left: 133 ,right:vec![ 97,136,98,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
134 => {
parser.sets[index].predict(State{rule: 85 ,left: 134 ,right:vec![ 135 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 86 ,left: 134 ,right:vec![ 134,79,135 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 87 ,left: 134 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
135 => {
parser.sets[index].predict(State{rule: 88 ,left: 135 ,right:vec![ 117,309,86,237 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
136 => {
parser.sets[index].predict(State{rule: 89 ,left: 136 ,right:vec![ 137 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 90 ,left: 136 ,right:vec![ 136,79,137 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 91 ,left: 136 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
137 => {
parser.sets[index].predict(State{rule: 92 ,left: 137 ,right:vec![ 117,237 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
138 => {
parser.sets[index].predict(State{rule: 93 ,left: 138 ,right:vec![ 8,309,200,201,99,139,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 94 ,left: 138 ,right:vec![ 8,309,200,201,99,139,100,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
139 => {
parser.sets[index].predict(State{rule: 95 ,left: 139 ,right:vec![ 140 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 96 ,left: 139 ,right:vec![ 139,79,140 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 97 ,left: 139 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
140 => {
parser.sets[index].predict(State{rule: 98 ,left: 140 ,right:vec![ 117,309,141 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
141 => {
parser.sets[index].predict(State{rule: 99 ,left: 141 ,right:vec![ 99,134,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 100 ,left: 141 ,right:vec![ 99,134,79,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 101 ,left: 141 ,right:vec![ 97,235,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 102 ,left: 141 ,right:vec![ 63,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 103 ,left: 141 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
142 => {
parser.sets[index].predict(State{rule: 104 ,left: 142 ,right:vec![ 9,309,200,201,99,134,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 105 ,left: 142 ,right:vec![ 9,309,200,201,99,134,79,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
143 => {
parser.sets[index].predict(State{rule: 106 ,left: 143 ,right:vec![ 10,309,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 107 ,left: 143 ,right:vec![ 10,309,99,115,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 108 ,left: 143 ,right:vec![ 10,309,99,108,115,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
144 => {
parser.sets[index].predict(State{rule: 109 ,left: 144 ,right:vec![ 5,145,99,146,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 110 ,left: 144 ,right:vec![ 5,145,99,108,146,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
145 => {
parser.sets[index].predict(State{rule: 111 ,left: 145 ,right:vec![ 307 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 112 ,left: 145 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
146 => {
parser.sets[index].predict(State{rule: 113 ,left: 146 ,right:vec![ 147 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 114 ,left: 146 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
147 => {
parser.sets[index].predict(State{rule: 115 ,left: 147 ,right:vec![ 148 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 116 ,left: 147 ,right:vec![ 147,148 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
148 => {
parser.sets[index].predict(State{rule: 117 ,left: 148 ,right:vec![ 117,1,149 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 118 ,left: 148 ,right:vec![ 117,150 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 119 ,left: 148 ,right:vec![ 117,11,150 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
149 => {
parser.sets[index].predict(State{rule: 120 ,left: 149 ,right:vec![ 231,309,86,224,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
150 => {
parser.sets[index].predict(State{rule: 121 ,left: 150 ,right:vec![ 12,309,200,151,201,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
151 => {
parser.sets[index].predict(State{rule: 122 ,left: 151 ,right:vec![ 152,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
152 => {
parser.sets[index].predict(State{rule: 123 ,left: 152 ,right:vec![ 97,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 124 ,left: 152 ,right:vec![ 97,188,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 125 ,left: 152 ,right:vec![ 97,188,79,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 126 ,left: 152 ,right:vec![ 97,188,79,82,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
153 => {
parser.sets[index].predict(State{rule: 127 ,left: 153 ,right:vec![ 13 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 128 ,left: 153 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
154 => {
parser.sets[index].predict(State{rule: 129 ,left: 154 ,right:vec![ 155 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 130 ,left: 154 ,right:vec![ 154,6,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 131 ,left: 154 ,right:vec![ 154,79,155 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
155 => {
parser.sets[index].predict(State{rule: 132 ,left: 155 ,right:vec![ 309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 133 ,left: 155 ,right:vec![ 14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
156 => {
parser.sets[index].predict(State{rule: 134 ,left: 156 ,right:vec![ 15,309,200,201,63,237,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
157 => {
parser.sets[index].predict(State{rule: 135 ,left: 157 ,right:vec![ 16,94,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 136 ,left: 157 ,right:vec![ 16,309,94 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 137 ,left: 157 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
158 => {
parser.sets[index].predict(State{rule: 138 ,left: 158 ,right:vec![ 165,17,309,200,157,241,201,99,159,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 10 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
159 => {
parser.sets[index].predict(State{rule: 139 ,left: 159 ,right:vec![ 160 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 140 ,left: 159 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
160 => {
parser.sets[index].predict(State{rule: 141 ,left: 160 ,right:vec![ 161 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 142 ,left: 160 ,right:vec![ 160,161 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
161 => {
parser.sets[index].predict(State{rule: 143 ,left: 161 ,right:vec![ 162 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 144 ,left: 161 ,right:vec![ 164 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 145 ,left: 161 ,right:vec![ 167 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 146 ,left: 161 ,right:vec![ 110,123 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
162 => {
parser.sets[index].predict(State{rule: 147 ,left: 162 ,right:vec![ 110,3,309,129,163,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
163 => {
parser.sets[index].predict(State{rule: 148 ,left: 163 ,right:vec![ 63,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 149 ,left: 163 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
164 => {
parser.sets[index].predict(State{rule: 150 ,left: 164 ,right:vec![ 110,15,247,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
165 => {
parser.sets[index].predict(State{rule: 151 ,left: 165 ,right:vec![ 11 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 152 ,left: 165 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
166 => {
parser.sets[index].predict(State{rule: 153 ,left: 166 ,right:vec![ 18,11 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 154 ,left: 166 ,right:vec![ 11 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 155 ,left: 166 ,right:vec![ 11 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 156 ,left: 166 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
167 => {
parser.sets[index].predict(State{rule: 157 ,left: 167 ,right:vec![ 168 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 158 ,left: 167 ,right:vec![ 169 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
168 => {
parser.sets[index].predict(State{rule: 159 ,left: 168 ,right:vec![ 110,165,12,309,200,182,201,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 160 ,left: 168 ,right:vec![ 110,3,165,12,309,200,182,201,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 9 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 161 ,left: 168 ,right:vec![ 110,165,5,145,12,309,200,182,201,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 10 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
169 => {
parser.sets[index].predict(State{rule: 162 ,left: 169 ,right:vec![ 110,165,12,309,200,182,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 163 ,left: 169 ,right:vec![ 110,3,165,12,309,200,182,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 9 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 164 ,left: 169 ,right:vec![ 110,165,5,145,12,309,200,182,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 10 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
170 => {
parser.sets[index].predict(State{rule: 165 ,left: 170 ,right:vec![ 117,175,165,12,309,200,181,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 9 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 166 ,left: 170 ,right:vec![ 117,175,3,165,12,309,200,181,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 10 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 167 ,left: 170 ,right:vec![ 117,175,165,5,145,12,309,200,181,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 11 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
171 => {
parser.sets[index].predict(State{rule: 168 ,left: 171 ,right:vec![ 166,19,200,239,201,99,107,172,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 9 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 169 ,left: 171 ,right:vec![ 166,19,200,97,224,98,201,99,107,172,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 11 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 170 ,left: 171 ,right:vec![ 166,19,200,258,16,237,201,99,107,172,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 11 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 171 ,left: 171 ,right:vec![ 166,19,200,91,258,16,237,201,99,107,172,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 12 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 172 ,left: 171 ,right:vec![ 166,19,200,258,16,83,99,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 173 ,left: 171 ,right:vec![ 166,19,200,91,258,16,83,99,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 9 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
172 => {
parser.sets[index].predict(State{rule: 174 ,left: 172 ,right:vec![ 173 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 175 ,left: 172 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
173 => {
parser.sets[index].predict(State{rule: 176 ,left: 173 ,right:vec![ 174 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 177 ,left: 173 ,right:vec![ 174,173 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
174 => {
parser.sets[index].predict(State{rule: 178 ,left: 174 ,right:vec![ 170 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 179 ,left: 174 ,right:vec![ 117,123 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 180 ,left: 174 ,right:vec![ 176 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 181 ,left: 174 ,right:vec![ 177 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
175 => {
parser.sets[index].predict(State{rule: 182 ,left: 175 ,right:vec![ 18 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 183 ,left: 175 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
176 => {
parser.sets[index].predict(State{rule: 184 ,left: 176 ,right:vec![ 117,175,122 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
177 => {
parser.sets[index].predict(State{rule: 185 ,left: 177 ,right:vec![ 117,175,15,309,200,63,237,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
178 => {
parser.sets[index].predict(State{rule: 186 ,left: 178 ,right:vec![ 12,309,200,180,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 187 ,left: 178 ,right:vec![ 3,12,309,200,180,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
179 => {
parser.sets[index].predict(State{rule: 188 ,left: 179 ,right:vec![ 11,12,309,200,180,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 189 ,left: 179 ,right:vec![ 3,11,12,309,200,180,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 190 ,left: 179 ,right:vec![ 11,5,145,12,309,200,180,201,259 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 9 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
180 => {
parser.sets[index].predict(State{rule: 191 ,left: 180 ,right:vec![ 183,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
181 => {
parser.sets[index].predict(State{rule: 192 ,left: 181 ,right:vec![ 185,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
182 => {
parser.sets[index].predict(State{rule: 193 ,left: 182 ,right:vec![ 186,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
183 => {
parser.sets[index].predict(State{rule: 194 ,left: 183 ,right:vec![ 97,187,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
184 => {
parser.sets[index].predict(State{rule: 195 ,left: 184 ,right:vec![ 97,196,197,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 196 ,left: 184 ,right:vec![ 97,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
185 => {
parser.sets[index].predict(State{rule: 197 ,left: 185 ,right:vec![ 97,231,14,129,192,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 198 ,left: 185 ,right:vec![ 97,81,231,14,129,192,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 199 ,left: 185 ,right:vec![ 97,81,257,231,14,129,192,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 200 ,left: 185 ,right:vec![ 97,187,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
186 => {
parser.sets[index].predict(State{rule: 201 ,left: 186 ,right:vec![ 97,231,14,129,193,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 202 ,left: 186 ,right:vec![ 97,81,231,14,129,193,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 203 ,left: 186 ,right:vec![ 97,81,257,231,14,129,193,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 204 ,left: 186 ,right:vec![ 97,194,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
187 => {
parser.sets[index].predict(State{rule: 205 ,left: 187 ,right:vec![ 188 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 206 ,left: 187 ,right:vec![ 188,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 207 ,left: 187 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
188 => {
parser.sets[index].predict(State{rule: 208 ,left: 188 ,right:vec![ 189 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 209 ,left: 188 ,right:vec![ 188,79,189 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
189 => {
parser.sets[index].predict(State{rule: 210 ,left: 189 ,right:vec![ 213,86,237 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
190 => {
parser.sets[index].predict(State{rule: 211 ,left: 190 ,right:vec![ 191 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 212 ,left: 190 ,right:vec![ 190,79,191 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
191 => {
parser.sets[index].predict(State{rule: 213 ,left: 191 ,right:vec![ 213,129 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
192 => {
parser.sets[index].predict(State{rule: 214 ,left: 192 ,right:vec![ 79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 215 ,left: 192 ,right:vec![ 79,188 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 216 ,left: 192 ,right:vec![ 79,188,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 217 ,left: 192 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
193 => {
parser.sets[index].predict(State{rule: 218 ,left: 193 ,right:vec![ 79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 219 ,left: 193 ,right:vec![ 79,195 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 220 ,left: 193 ,right:vec![ 79,195,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 221 ,left: 193 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
194 => {
parser.sets[index].predict(State{rule: 222 ,left: 194 ,right:vec![ 195 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 223 ,left: 194 ,right:vec![ 195,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 224 ,left: 194 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
195 => {
parser.sets[index].predict(State{rule: 225 ,left: 195 ,right:vec![ 196 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 226 ,left: 195 ,right:vec![ 195,79,196 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
196 => {
parser.sets[index].predict(State{rule: 227 ,left: 196 ,right:vec![ 198,86,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 228 ,left: 196 ,right:vec![ 224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
197 => {
parser.sets[index].predict(State{rule: 229 ,left: 197 ,right:vec![ 79,82 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 230 ,left: 197 ,right:vec![ 79,196,197 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 231 ,left: 197 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
198 => {
parser.sets[index].predict(State{rule: 232 ,left: 198 ,right:vec![ 309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 233 ,left: 198 ,right:vec![ 76 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 234 ,left: 198 ,right:vec![ 81,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 235 ,left: 198 ,right:vec![ 81,76 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 236 ,left: 198 ,right:vec![ 80,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 237 ,left: 198 ,right:vec![ 80,76 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 238 ,left: 198 ,right:vec![ 2,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
199 => {
parser.sets[index].predict(State{rule: 239 ,left: 199 ,right:vec![ 65,91 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 240 ,left: 199 ,right:vec![ 65,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 241 ,left: 199 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
200 => {
parser.sets[index].predict(State{rule: 242 ,left: 200 ,right:vec![ 101,102,317 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 243 ,left: 200 ,right:vec![ 101,255,102,317 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 244 ,left: 200 ,right:vec![ 101,255,79,102,317 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 245 ,left: 200 ,right:vec![ 101,255,79,206,102,317 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 246 ,left: 200 ,right:vec![ 101,255,79,206,79,102,317 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 247 ,left: 200 ,right:vec![ 101,206,102 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 248 ,left: 200 ,right:vec![ 101,206,79,102 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 249 ,left: 200 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
201 => {
parser.sets[index].predict(State{rule: 250 ,left: 201 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 251 ,left: 201 ,right:vec![ 202 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
202 => {
parser.sets[index].predict(State{rule: 252 ,left: 202 ,right:vec![ 20,203 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 253 ,left: 202 ,right:vec![ 20,203,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
203 => {
parser.sets[index].predict(State{rule: 254 ,left: 203 ,right:vec![ 204 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 255 ,left: 203 ,right:vec![ 203,79,204 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
204 => {
parser.sets[index].predict(State{rule: 256 ,left: 204 ,right:vec![ 205,257,86,249 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 257 ,left: 204 ,right:vec![ 205,224,86,242 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
205 => {
parser.sets[index].predict(State{rule: 258 ,left: 205 ,right:vec![ 16,101,255,102 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 259 ,left: 205 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
206 => {
parser.sets[index].predict(State{rule: 260 ,left: 206 ,right:vec![ 247 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 261 ,left: 206 ,right:vec![ 206,79,247 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
207 => {
parser.sets[index].predict(State{rule: 262 ,left: 207 ,right:vec![ 309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 263 ,left: 207 ,right:vec![ 85,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 264 ,left: 207 ,right:vec![ 14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 265 ,left: 207 ,right:vec![ 85,14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 266 ,left: 207 ,right:vec![ 21 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 267 ,left: 207 ,right:vec![ 85,21 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 268 ,left: 207 ,right:vec![ 207,85,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
208 => {
parser.sets[index].predict(State{rule: 269 ,left: 208 ,right:vec![ 309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 270 ,left: 208 ,right:vec![ 309,209 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 271 ,left: 208 ,right:vec![ 309,97,235,98,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 272 ,left: 208 ,right:vec![ 208,85,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 273 ,left: 208 ,right:vec![ 208,85,309,209 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 274 ,left: 208 ,right:vec![ 208,85,309,97,235,98,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
209 => {
parser.sets[index].predict(State{rule: 275 ,left: 209 ,right:vec![ 101,317,210,102,317 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 276 ,left: 209 ,right:vec![ 101,317,210,67,317 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
210 => {
parser.sets[index].predict(State{rule: 277 ,left: 210 ,right:vec![ 211 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
211 => {
parser.sets[index].predict(State{rule: 278 ,left: 211 ,right:vec![ 236 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 279 ,left: 211 ,right:vec![ 236,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 280 ,left: 211 ,right:vec![ 236,79,245 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 281 ,left: 211 ,right:vec![ 245 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 282 ,left: 211 ,right:vec![ 245,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 283 ,left: 211 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
212 => {
parser.sets[index].predict(State{rule: 284 ,left: 212 ,right:vec![ 79,245 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 285 ,left: 212 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
213 => {
parser.sets[index].predict(State{rule: 286 ,left: 213 ,right:vec![ 76 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 287 ,left: 213 ,right:vec![ 81,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 288 ,left: 213 ,right:vec![ 81,2,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 289 ,left: 213 ,right:vec![ 80,2,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 290 ,left: 213 ,right:vec![ 97,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 291 ,left: 213 ,right:vec![ 97,220,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 292 ,left: 213 ,right:vec![ 95,222,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 293 ,left: 213 ,right:vec![ 216 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 294 ,left: 213 ,right:vec![ 216,82,216 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 295 ,left: 213 ,right:vec![ 267,99,219,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 296 ,left: 213 ,right:vec![ 267,97,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 297 ,left: 213 ,right:vec![ 267,97,220,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 298 ,left: 213 ,right:vec![ 267,91,308,313 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 299 ,left: 213 ,right:vec![ 215,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 300 ,left: 213 ,right:vec![ 309,92,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 301 ,left: 213 ,right:vec![ 215,309,92,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 302 ,left: 213 ,right:vec![ 22,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 303 ,left: 213 ,right:vec![ 101,237,277,102,85,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
214 => {
parser.sets[index].predict(State{rule: 304 ,left: 214 ,right:vec![ 213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 305 ,left: 214 ,right:vec![ 214,78,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
215 => {
parser.sets[index].predict(State{rule: 306 ,left: 215 ,right:vec![ 23 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 307 ,left: 215 ,right:vec![ 23,2 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 308 ,left: 215 ,right:vec![ 2 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
216 => {
parser.sets[index].predict(State{rule: 309 ,left: 216 ,right:vec![ 267 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 310 ,left: 216 ,right:vec![ 306 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 311 ,left: 216 ,right:vec![ 104,306 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
217 => {
parser.sets[index].predict(State{rule: 312 ,left: 217 ,right:vec![ 309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 313 ,left: 217 ,right:vec![ 215,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 314 ,left: 217 ,right:vec![ 22,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 315 ,left: 217 ,right:vec![ 22,215,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 316 ,left: 217 ,right:vec![ 309,86,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 317 ,left: 217 ,right:vec![ 215,309,86,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 318 ,left: 217 ,right:vec![ 45,86,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
218 => {
parser.sets[index].predict(State{rule: 319 ,left: 218 ,right:vec![ 217 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 320 ,left: 218 ,right:vec![ 218,79,217 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
219 => {
parser.sets[index].predict(State{rule: 321 ,left: 219 ,right:vec![ 218 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 322 ,left: 219 ,right:vec![ 218,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 323 ,left: 219 ,right:vec![ 218,79,83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 324 ,left: 219 ,right:vec![ 83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 325 ,left: 219 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
220 => {
parser.sets[index].predict(State{rule: 326 ,left: 220 ,right:vec![ 221 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 327 ,left: 220 ,right:vec![ 221,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 328 ,left: 220 ,right:vec![ 221,83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 329 ,left: 220 ,right:vec![ 221,79,83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 330 ,left: 220 ,right:vec![ 221,83,79,221 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 331 ,left: 220 ,right:vec![ 221,83,79,221,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 332 ,left: 220 ,right:vec![ 221,79,83,79,221 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 333 ,left: 220 ,right:vec![ 221,79,83,79,221,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 334 ,left: 220 ,right:vec![ 83,79,221 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 335 ,left: 220 ,right:vec![ 83,79,221,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 336 ,left: 220 ,right:vec![ 83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
221 => {
parser.sets[index].predict(State{rule: 337 ,left: 221 ,right:vec![ 213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 338 ,left: 221 ,right:vec![ 221,79,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
222 => {
parser.sets[index].predict(State{rule: 339 ,left: 222 ,right:vec![ 223 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 340 ,left: 222 ,right:vec![ 223,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 341 ,left: 222 ,right:vec![ 223,83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 342 ,left: 222 ,right:vec![ 223,79,83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 343 ,left: 222 ,right:vec![ 223,83,79,223 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 344 ,left: 222 ,right:vec![ 223,83,79,223,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 345 ,left: 222 ,right:vec![ 223,79,83,79,223 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 346 ,left: 222 ,right:vec![ 223,79,83,79,223,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 347 ,left: 222 ,right:vec![ 83,79,223 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 348 ,left: 222 ,right:vec![ 83,79,223,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 349 ,left: 222 ,right:vec![ 83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 350 ,left: 222 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
223 => {
parser.sets[index].predict(State{rule: 351 ,left: 223 ,right:vec![ 213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 352 ,left: 223 ,right:vec![ 223,79,213 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
224 => {
parser.sets[index].predict(State{rule: 353 ,left: 224 ,right:vec![ 225 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 354 ,left: 224 ,right:vec![ 228 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 355 ,left: 224 ,right:vec![ 101,237,277,102,85,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 356 ,left: 224 ,right:vec![ 97,236,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 357 ,left: 224 ,right:vec![ 97,236,79,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 358 ,left: 224 ,right:vec![ 97,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
225 => {
parser.sets[index].predict(State{rule: 359 ,left: 225 ,right:vec![ 208 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 360 ,left: 225 ,right:vec![ 85,208 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 361 ,left: 225 ,right:vec![ 14,85,208 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 362 ,left: 225 ,right:vec![ 208,91,308,313 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 363 ,left: 225 ,right:vec![ 85,208,91,308,313 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 364 ,left: 225 ,right:vec![ 22,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 365 ,left: 225 ,right:vec![ 93,232,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 366 ,left: 225 ,right:vec![ 81,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 367 ,left: 225 ,right:vec![ 81,2,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 368 ,left: 225 ,right:vec![ 80,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 369 ,left: 225 ,right:vec![ 80,2,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 370 ,left: 225 ,right:vec![ 81,257,231,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 371 ,left: 225 ,right:vec![ 95,224,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 372 ,left: 225 ,right:vec![ 95,224,79,83,271,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 373 ,left: 225 ,right:vec![ 95,224,90,271,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 374 ,left: 225 ,right:vec![ 24,97,271,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 375 ,left: 225 ,right:vec![ 76 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 376 ,left: 225 ,right:vec![ 226 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 377 ,left: 225 ,right:vec![ 229 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
226 => {
parser.sets[index].predict(State{rule: 378 ,left: 226 ,right:vec![ 12,227 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 379 ,left: 226 ,right:vec![ 11,12,227 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 380 ,left: 226 ,right:vec![ 5,12,227 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 381 ,left: 226 ,right:vec![ 11,5,12,227 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
227 => {
parser.sets[index].predict(State{rule: 382 ,left: 227 ,right:vec![ 200,184,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
228 => {
parser.sets[index].predict(State{rule: 383 ,left: 228 ,right:vec![ 11,78,195,78,248,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 384 ,left: 228 ,right:vec![ 78,195,78,248,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 385 ,left: 228 ,right:vec![ 11,77,248,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 386 ,left: 228 ,right:vec![ 77,248,199 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
229 => {
parser.sets[index].predict(State{rule: 387 ,left: 229 ,right:vec![ 16,101,254,102,230 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
230 => {
parser.sets[index].predict(State{rule: 388 ,left: 230 ,right:vec![ 226 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 389 ,left: 230 ,right:vec![ 258 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 390 ,left: 230 ,right:vec![ 228 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
231 => {
parser.sets[index].predict(State{rule: 391 ,left: 231 ,right:vec![ 2 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 392 ,left: 231 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
232 => {
parser.sets[index].predict(State{rule: 393 ,left: 232 ,right:vec![ 2 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 394 ,left: 232 ,right:vec![ 3 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 395 ,left: 232 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
233 => {
parser.sets[index].predict(State{rule: 396 ,left: 233 ,right:vec![ 234,212 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 397 ,left: 233 ,right:vec![ 234,79,236,212 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
234 => {
parser.sets[index].predict(State{rule: 398 ,left: 234 ,right:vec![ 236,6,258,102,85,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 399 ,left: 234 ,right:vec![ 236,6,258,102,85,309,103,242 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
235 => {
parser.sets[index].predict(State{rule: 400 ,left: 235 ,right:vec![ 236 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 401 ,left: 235 ,right:vec![ 236,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 402 ,left: 235 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
236 => {
parser.sets[index].predict(State{rule: 403 ,left: 236 ,right:vec![ 237 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 404 ,left: 236 ,right:vec![ 236,79,237 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
237 => {
parser.sets[index].predict(State{rule: 405 ,left: 237 ,right:vec![ 238 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 406 ,left: 237 ,right:vec![ 237,103,238 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
238 => {
parser.sets[index].predict(State{rule: 407 ,left: 238 ,right:vec![ 224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 408 ,left: 238 ,right:vec![ 257 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
239 => {
parser.sets[index].predict(State{rule: 409 ,left: 239 ,right:vec![ 240 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 410 ,left: 239 ,right:vec![ 239,103,240 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
240 => {
parser.sets[index].predict(State{rule: 411 ,left: 240 ,right:vec![ 225 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 412 ,left: 240 ,right:vec![ 257 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
241 => {
parser.sets[index].predict(State{rule: 413 ,left: 241 ,right:vec![ 86,242 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 414 ,left: 241 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
242 => {
parser.sets[index].predict(State{rule: 415 ,left: 242 ,right:vec![ 243 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 416 ,left: 242 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
243 => {
parser.sets[index].predict(State{rule: 417 ,left: 243 ,right:vec![ 244 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 418 ,left: 243 ,right:vec![ 243,103,244 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
244 => {
parser.sets[index].predict(State{rule: 419 ,left: 244 ,right:vec![ 16,101,254,102,250 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 420 ,left: 244 ,right:vec![ 250 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 421 ,left: 244 ,right:vec![ 94,16,101,254,102,250 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 422 ,left: 244 ,right:vec![ 94,250 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
245 => {
parser.sets[index].predict(State{rule: 423 ,left: 245 ,right:vec![ 246 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 424 ,left: 245 ,right:vec![ 245,79,246 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
246 => {
parser.sets[index].predict(State{rule: 425 ,left: 246 ,right:vec![ 309,63,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
247 => {
parser.sets[index].predict(State{rule: 426 ,left: 247 ,right:vec![ 309,241,253 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 427 ,left: 247 ,right:vec![ 309,94,309,241,253 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
248 => {
parser.sets[index].predict(State{rule: 428 ,left: 248 ,right:vec![ 86,249 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 429 ,left: 248 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
249 => {
parser.sets[index].predict(State{rule: 430 ,left: 249 ,right:vec![ 249 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 431 ,left: 249 ,right:vec![ 249,103,250 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
250 => {
parser.sets[index].predict(State{rule: 432 ,left: 250 ,right:vec![ 257 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 433 ,left: 250 ,right:vec![ 258 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
251 => {
parser.sets[index].predict(State{rule: 434 ,left: 251 ,right:vec![ 86,252 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 435 ,left: 251 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
252 => {
parser.sets[index].predict(State{rule: 436 ,left: 252 ,right:vec![ 257 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 437 ,left: 252 ,right:vec![ 252,103,257 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
253 => {
parser.sets[index].predict(State{rule: 438 ,left: 253 ,right:vec![ 63,237 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 439 ,left: 253 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
254 => {
parser.sets[index].predict(State{rule: 440 ,left: 254 ,right:vec![ 255 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 441 ,left: 254 ,right:vec![ 255,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 442 ,left: 254 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
255 => {
parser.sets[index].predict(State{rule: 443 ,left: 255 ,right:vec![ 256 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 444 ,left: 255 ,right:vec![ 255,79,256 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
256 => {
parser.sets[index].predict(State{rule: 445 ,left: 256 ,right:vec![ 46,251 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 446 ,left: 256 ,right:vec![ 25 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
257 => {
parser.sets[index].predict(State{rule: 447 ,left: 257 ,right:vec![ 46 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 448 ,left: 257 ,right:vec![ 25 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
258 => {
parser.sets[index].predict(State{rule: 449 ,left: 258 ,right:vec![ 208 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 450 ,left: 258 ,right:vec![ 85,208 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
259 => {
parser.sets[index].predict(State{rule: 451 ,left: 259 ,right:vec![ 99,107,261,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
260 => {
parser.sets[index].predict(State{rule: 452 ,left: 260 ,right:vec![ 99,261,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
261 => {
parser.sets[index].predict(State{rule: 453 ,left: 261 ,right:vec![ 262 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 454 ,left: 261 ,right:vec![ 262,270 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 455 ,left: 261 ,right:vec![ 270 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 456 ,left: 261 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
262 => {
parser.sets[index].predict(State{rule: 457 ,left: 262 ,right:vec![ 263 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 458 ,left: 262 ,right:vec![ 262,263 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
263 => {
parser.sets[index].predict(State{rule: 459 ,left: 263 ,right:vec![ 110,305 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 460 ,left: 263 ,right:vec![ 120 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 461 ,left: 263 ,right:vec![ 13,120 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 462 ,left: 263 ,right:vec![ 111,120 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 463 ,left: 263 ,right:vec![ 111,13,120 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 464 ,left: 263 ,right:vec![ 289 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 465 ,left: 263 ,right:vec![ 110,260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 466 ,left: 263 ,right:vec![ 270,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 467 ,left: 263 ,right:vec![ 111,270,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 468 ,left: 263 ,right:vec![ 90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
264 => {
parser.sets[index].predict(State{rule: 469 ,left: 264 ,right:vec![ 266 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 470 ,left: 264 ,right:vec![ 266,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 471 ,left: 264 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
265 => {
parser.sets[index].predict(State{rule: 472 ,left: 265 ,right:vec![ 271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 473 ,left: 265 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
266 => {
parser.sets[index].predict(State{rule: 474 ,left: 266 ,right:vec![ 271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 475 ,left: 266 ,right:vec![ 266,79,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
267 => {
parser.sets[index].predict(State{rule: 476 ,left: 267 ,right:vec![ 268 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 477 ,left: 267 ,right:vec![ 85,268 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 478 ,left: 267 ,right:vec![ 14,85,268 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
268 => {
parser.sets[index].predict(State{rule: 479 ,left: 268 ,right:vec![ 309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 470 ,left: 268 ,right:vec![ 21 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 481 ,left: 268 ,right:vec![ 268,85,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 482 ,left: 268 ,right:vec![ 268,85,21 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 483 ,left: 268 ,right:vec![ 268,85,209 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
269 => {
parser.sets[index].predict(State{rule: 484 ,left: 269 ,right:vec![ 267,91,308,314 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 485 ,left: 269 ,right:vec![ 267,91,308,316 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
270 => {
parser.sets[index].predict(State{rule: 486 ,left: 270 ,right:vec![ 306 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 487 ,left: 270 ,right:vec![ 267 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 488 ,left: 270 ,right:vec![ 14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 489 ,left: 270 ,right:vec![ 269 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 490 ,left: 270 ,right:vec![ 267,99,283,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 491 ,left: 270 ,right:vec![ 270,94 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 492 ,left: 270 ,right:vec![ 270,84,268 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 493 ,left: 270 ,right:vec![ 270,84,45 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 494 ,left: 270 ,right:vec![ 270,95,265,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 495 ,left: 270 ,right:vec![ 270,97,264,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 496 ,left: 270 ,right:vec![ 95,282,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 497 ,left: 270 ,right:vec![ 97,264,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 498 ,left: 270 ,right:vec![ 26 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 499 ,left: 270 ,right:vec![ 26,257 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 500 ,left: 270 ,right:vec![ 27 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 501 ,left: 270 ,right:vec![ 27,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 502 ,left: 270 ,right:vec![ 28 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 503 ,left: 270 ,right:vec![ 28,257 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 504 ,left: 270 ,right:vec![ 29 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 505 ,left: 270 ,right:vec![ 29,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 506 ,left: 270 ,right:vec![ 270,64,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 507 ,left: 270 ,right:vec![ 270,63,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 508 ,left: 270 ,right:vec![ 270,101,54,101,63,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 509 ,left: 270 ,right:vec![ 270,102,54,102,63,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 510 ,left: 270 ,right:vec![ 270,68,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 511 ,left: 270 ,right:vec![ 270,69,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 512 ,left: 270 ,right:vec![ 270,70,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 513 ,left: 270 ,right:vec![ 270,71,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 514 ,left: 270 ,right:vec![ 270,72,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 515 ,left: 270 ,right:vec![ 270,73,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 516 ,left: 270 ,right:vec![ 270,74,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 517 ,left: 270 ,right:vec![ 270,75,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 518 ,left: 270 ,right:vec![ 270,77,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 519 ,left: 270 ,right:vec![ 270,80,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 520 ,left: 270 ,right:vec![ 270,61,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 521 ,left: 270 ,right:vec![ 270,62,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 522 ,left: 270 ,right:vec![ 270,101,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 523 ,left: 270 ,right:vec![ 270,102,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 524 ,left: 270 ,right:vec![ 270,66,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 525 ,left: 270 ,right:vec![ 270,67,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 526 ,left: 270 ,right:vec![ 270,78,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 527 ,left: 270 ,right:vec![ 270,87,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 528 ,left: 270 ,right:vec![ 270,81,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 529 ,left: 270 ,right:vec![ 270,101,54,101,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 530 ,left: 270 ,right:vec![ 270,102,54,102,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 531 ,left: 270 ,right:vec![ 270,103,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 532 ,left: 270 ,right:vec![ 270,104,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 533 ,left: 270 ,right:vec![ 270,93,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 534 ,left: 270 ,right:vec![ 270,88,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 535 ,left: 270 ,right:vec![ 270,89,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 536 ,left: 270 ,right:vec![ 270,83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 537 ,left: 270 ,right:vec![ 270,83,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 538 ,left: 270 ,right:vec![ 83,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 539 ,left: 270 ,right:vec![ 83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 540 ,left: 270 ,right:vec![ 270,6,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 541 ,left: 270 ,right:vec![ 270,86,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 542 ,left: 270 ,right:vec![ 22,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 543 ,left: 270 ,right:vec![ 275 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 544 ,left: 270 ,right:vec![ 274 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
271 => {
parser.sets[index].predict(State{rule: 545 ,left: 271 ,right:vec![ 306 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 546 ,left: 271 ,right:vec![ 267 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 547 ,left: 271 ,right:vec![ 14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 548 ,left: 271 ,right:vec![ 269 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 549 ,left: 271 ,right:vec![ 267,99,283,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 550 ,left: 271 ,right:vec![ 271,94 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 551 ,left: 271 ,right:vec![ 271,84,268 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 552 ,left: 271 ,right:vec![ 271,84,45 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 553 ,left: 271 ,right:vec![ 271,95,265,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 554 ,left: 271 ,right:vec![ 271,97,264,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 555 ,left: 271 ,right:vec![ 97,264,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 556 ,left: 271 ,right:vec![ 95,282,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 557 ,left: 271 ,right:vec![ 26 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 558 ,left: 271 ,right:vec![ 26,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 559 ,left: 271 ,right:vec![ 27 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 560 ,left: 271 ,right:vec![ 27,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 561 ,left: 271 ,right:vec![ 28 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 562 ,left: 271 ,right:vec![ 28,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 563 ,left: 271 ,right:vec![ 29 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 564 ,left: 271 ,right:vec![ 29,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 565 ,left: 271 ,right:vec![ 271,64,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 566 ,left: 271 ,right:vec![ 271,63,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 567 ,left: 271 ,right:vec![ 271,101,54,101,63,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 568 ,left: 271 ,right:vec![ 271,102,54,102,63,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 569 ,left: 271 ,right:vec![ 271,68,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 570 ,left: 271 ,right:vec![ 271,69,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 571 ,left: 271 ,right:vec![ 271,70,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 572 ,left: 271 ,right:vec![ 271,71,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 573 ,left: 271 ,right:vec![ 271,72,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 574 ,left: 271 ,right:vec![ 271,73,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 575 ,left: 271 ,right:vec![ 271,74,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 576 ,left: 271 ,right:vec![ 271,75,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 577 ,left: 271 ,right:vec![ 271,77,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 578 ,left: 271 ,right:vec![ 271,80,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 579 ,left: 271 ,right:vec![ 271,61,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 580 ,left: 271 ,right:vec![ 271,62,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 581 ,left: 271 ,right:vec![ 271,101,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 582 ,left: 271 ,right:vec![ 271,102,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 583 ,left: 271 ,right:vec![ 271,66,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 584 ,left: 271 ,right:vec![ 271,67,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 585 ,left: 271 ,right:vec![ 271,78,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 586 ,left: 271 ,right:vec![ 271,87,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 587 ,left: 271 ,right:vec![ 271,81,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 588 ,left: 271 ,right:vec![ 271,101,54,101,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 589 ,left: 271 ,right:vec![ 271,102,54,102,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 590 ,left: 271 ,right:vec![ 271,103,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 591 ,left: 271 ,right:vec![ 271,104,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 592 ,left: 271 ,right:vec![ 271,93,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 593 ,left: 271 ,right:vec![ 271,88,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 594 ,left: 271 ,right:vec![ 271,89,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 595 ,left: 271 ,right:vec![ 271,83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 596 ,left: 271 ,right:vec![ 271,83,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 597 ,left: 271 ,right:vec![ 83,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 598 ,left: 271 ,right:vec![ 83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 599 ,left: 271 ,right:vec![ 271,6,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 600 ,left: 271 ,right:vec![ 271,86,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 601 ,left: 271 ,right:vec![ 22,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 602 ,left: 271 ,right:vec![ 275 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 603 ,left: 271 ,right:vec![ 288 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 604 ,left: 271 ,right:vec![ 260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 605 ,left: 271 ,right:vec![ 274 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
272 => {
parser.sets[index].predict(State{rule: 606 ,left: 272 ,right:vec![ 306 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 607 ,left: 272 ,right:vec![ 267 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 608 ,left: 272 ,right:vec![ 14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 609 ,left: 272 ,right:vec![ 269 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 610 ,left: 272 ,right:vec![ 272,94 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 611 ,left: 272 ,right:vec![ 272,84,268 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 612 ,left: 272 ,right:vec![ 272,84,45 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 613 ,left: 272 ,right:vec![ 272,95,265,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 614 ,left: 272 ,right:vec![ 272,97,264,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 615 ,left: 272 ,right:vec![ 95,282,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 616 ,left: 272 ,right:vec![ 97,264,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 617 ,left: 272 ,right:vec![ 26 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 618 ,left: 272 ,right:vec![ 26,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 619 ,left: 272 ,right:vec![ 27 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 620 ,left: 272 ,right:vec![ 27,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 621 ,left: 272 ,right:vec![ 28 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 622 ,left: 272 ,right:vec![ 28,309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 623 ,left: 272 ,right:vec![ 29 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 624 ,left: 272 ,right:vec![ 29,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 625 ,left: 272 ,right:vec![ 272,64,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 626 ,left: 272 ,right:vec![ 272,63,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 627 ,left: 272 ,right:vec![ 272,101,54,101,63,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 628 ,left: 272 ,right:vec![ 272,102,54,102,63,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 629 ,left: 272 ,right:vec![ 272,68,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 630 ,left: 272 ,right:vec![ 272,69,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 631 ,left: 272 ,right:vec![ 272,70,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 632 ,left: 272 ,right:vec![ 272,71,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 633 ,left: 272 ,right:vec![ 272,72,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 634 ,left: 272 ,right:vec![ 272,73,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 635 ,left: 272 ,right:vec![ 272,74,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 636 ,left: 272 ,right:vec![ 272,75,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 637 ,left: 272 ,right:vec![ 272,77,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 638 ,left: 272 ,right:vec![ 272,80,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 639 ,left: 272 ,right:vec![ 272,61,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 640 ,left: 272 ,right:vec![ 272,62,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 641 ,left: 272 ,right:vec![ 272,101,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 642 ,left: 272 ,right:vec![ 272,102,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 643 ,left: 272 ,right:vec![ 272,66,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 644 ,left: 272 ,right:vec![ 272,67,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 645 ,left: 272 ,right:vec![ 272,78,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 646 ,left: 272 ,right:vec![ 272,87,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 647 ,left: 272 ,right:vec![ 272,81,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 648 ,left: 272 ,right:vec![ 272,101,54,101,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 649 ,left: 272 ,right:vec![ 272,102,54,102,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 650 ,left: 272 ,right:vec![ 272,103,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 651 ,left: 272 ,right:vec![ 272,104,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 652 ,left: 272 ,right:vec![ 272,93,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 653 ,left: 272 ,right:vec![ 272,88,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 654 ,left: 272 ,right:vec![ 272,89,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 655 ,left: 272 ,right:vec![ 272,83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 656 ,left: 272 ,right:vec![ 272,83,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 657 ,left: 272 ,right:vec![ 83,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 658 ,left: 272 ,right:vec![ 83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 659 ,left: 272 ,right:vec![ 272,6,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 660 ,left: 272 ,right:vec![ 272,86,224 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 661 ,left: 272 ,right:vec![ 22,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 662 ,left: 272 ,right:vec![ 275 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 663 ,left: 272 ,right:vec![ 288 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 664 ,left: 272 ,right:vec![ 260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 665 ,left: 272 ,right:vec![ 273 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
273 => {
parser.sets[index].predict(State{rule: 666 ,left: 273 ,right:vec![ 104,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 667 ,left: 273 ,right:vec![ 91,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 668 ,left: 273 ,right:vec![ 93,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 669 ,left: 273 ,right:vec![ 81,231,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 670 ,left: 273 ,right:vec![ 80,231,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 671 ,left: 273 ,right:vec![ 280 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 672 ,left: 273 ,right:vec![ 30,280 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
274 => {
parser.sets[index].predict(State{rule: 673 ,left: 274 ,right:vec![ 104,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 674 ,left: 274 ,right:vec![ 91,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 675 ,left: 274 ,right:vec![ 93,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 676 ,left: 274 ,right:vec![ 81,231,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 677 ,left: 274 ,right:vec![ 80,231,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 678 ,left: 274 ,right:vec![ 278 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 679 ,left: 274 ,right:vec![ 30,278 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
275 => {
parser.sets[index].predict(State{rule: 680 ,left: 275 ,right:vec![ 101,237,277,102,85,309,276 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
276 => {
parser.sets[index].predict(State{rule: 681 ,left: 276 ,right:vec![ 85,209 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 682 ,left: 276 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
277 => {
parser.sets[index].predict(State{rule: 683 ,left: 277 ,right:vec![ 6,258 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 684 ,left: 277 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
278 => {
parser.sets[index].predict(State{rule: 685 ,left: 278 ,right:vec![ 77,199,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 686 ,left: 278 ,right:vec![ 78,78,199,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 687 ,left: 278 ,right:vec![ 78,190,78,199,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 688 ,left: 278 ,right:vec![ 78,190,77,279 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
279 => {
parser.sets[index].predict(State{rule: 689 ,left: 279 ,right:vec![ 78,199,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 690 ,left: 279 ,right:vec![ 190,78,199,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 691 ,left: 279 ,right:vec![ 190,77,279 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
280 => {
parser.sets[index].predict(State{rule: 692 ,left: 280 ,right:vec![ 77,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 693 ,left: 280 ,right:vec![ 78,78,199,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 694 ,left: 280 ,right:vec![ 78,190,78,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 695 ,left: 280 ,right:vec![ 78,190,77,281 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
281 => {
parser.sets[index].predict(State{rule: 696 ,left: 281 ,right:vec![ 78,199,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 697 ,left: 281 ,right:vec![ 190,78,199,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 698 ,left: 281 ,right:vec![ 190,77,281 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
282 => {
parser.sets[index].predict(State{rule: 699 ,left: 282 ,right:vec![ 264 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 700 ,left: 282 ,right:vec![ 266,90,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
283 => {
parser.sets[index].predict(State{rule: 701 ,left: 283 ,right:vec![ 285 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 702 ,left: 283 ,right:vec![ 285,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 703 ,left: 283 ,right:vec![ 284,287 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 704 ,left: 283 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
284 => {
parser.sets[index].predict(State{rule: 705 ,left: 284 ,right:vec![ 285 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 706 ,left: 284 ,right:vec![ 285,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 707 ,left: 284 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
285 => {
parser.sets[index].predict(State{rule: 708 ,left: 285 ,right:vec![ 286 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 709 ,left: 285 ,right:vec![ 285,79,286 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
286 => {
parser.sets[index].predict(State{rule: 710 ,left: 286 ,right:vec![ 309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 711 ,left: 286 ,right:vec![ 309,86,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 712 ,left: 286 ,right:vec![ 45,86,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
287 => {
parser.sets[index].predict(State{rule: 713 ,left: 287 ,right:vec![ 83,271 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
288 => {
parser.sets[index].predict(State{rule: 714 ,left: 288 ,right:vec![ 291 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 715 ,left: 288 ,right:vec![ 297 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 716 ,left: 288 ,right:vec![ 298 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 717 ,left: 288 ,right:vec![ 300 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 718 ,left: 288 ,right:vec![ 301 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 719 ,left: 288 ,right:vec![ 302 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 720 ,left: 288 ,right:vec![ 303 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 721 ,left: 288 ,right:vec![ 11,260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 722 ,left: 288 ,right:vec![ 267,91,308,315 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
289 => {
parser.sets[index].predict(State{rule: 723 ,left: 289 ,right:vec![ 288 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 724 ,left: 289 ,right:vec![ 290 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
290 => {
parser.sets[index].predict(State{rule: 725 ,left: 290 ,right:vec![ 288,84,268 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 726 ,left: 290 ,right:vec![ 290,84,268 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 727 ,left: 290 ,right:vec![ 288,84,268,95,265,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 728 ,left: 290 ,right:vec![ 290,84,268,95,265,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 729 ,left: 290 ,right:vec![ 288,84,268,97,264,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 730 ,left: 290 ,right:vec![ 290,84,268,97,264,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 731 ,left: 290 ,right:vec![ 288,84,45 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 732 ,left: 290 ,right:vec![ 290,84,45 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
291 => {
parser.sets[index].predict(State{rule: 733 ,left: 291 ,right:vec![ 31,272,99,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 734 ,left: 291 ,right:vec![ 31,272,99,292,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 735 ,left: 291 ,right:vec![ 31,272,99,292,294,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 736 ,left: 291 ,right:vec![ 31,272,99,294,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
292 => {
parser.sets[index].predict(State{rule: 737 ,left: 292 ,right:vec![ 293 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 738 ,left: 292 ,right:vec![ 292,293 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
293 => {
parser.sets[index].predict(State{rule: 739 ,left: 293 ,right:vec![ 294,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 740 ,left: 293 ,right:vec![ 295 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 741 ,left: 293 ,right:vec![ 295,79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
294 => {
parser.sets[index].predict(State{rule: 742 ,left: 294 ,right:vec![ 110,214,296,60,270 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 743 ,left: 294 ,right:vec![ 110,214,296,60,290 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
295 => {
parser.sets[index].predict(State{rule: 744 ,left: 295 ,right:vec![ 110,214,296,60,260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 745 ,left: 295 ,right:vec![ 110,214,296,60,288 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
296 => {
parser.sets[index].predict(State{rule: 746 ,left: 296 ,right:vec![ 32,272 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 747 ,left: 296 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
297 => {
parser.sets[index].predict(State{rule: 748 ,left: 297 ,right:vec![ 32,272,260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 749 ,left: 297 ,right:vec![ 32,272,260,33,299 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
298 => {
parser.sets[index].predict(State{rule: 750 ,left: 298 ,right:vec![ 32,34,213,63,272,260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 751 ,left: 298 ,right:vec![ 32,34,213,63,272,260,33,299 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
299 => {
parser.sets[index].predict(State{rule: 752 ,left: 299 ,right:vec![ 260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 753 ,left: 299 ,right:vec![ 297 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 754 ,left: 299 ,right:vec![ 298 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
300 => {
parser.sets[index].predict(State{rule: 755 ,left: 300 ,right:vec![ 304,35,272,260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 4 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
301 => {
parser.sets[index].predict(State{rule: 756 ,left: 301 ,right:vec![ 304,35,34,213,63,272,260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 7 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
302 => {
parser.sets[index].predict(State{rule: 757 ,left: 302 ,right:vec![ 304,36,260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
303 => {
parser.sets[index].predict(State{rule: 758 ,left: 303 ,right:vec![ 304,16,213,37,272,260 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 6 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
304 => {
parser.sets[index].predict(State{rule: 759 ,left: 304 ,right:vec![ 257,86 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 760 ,left: 304 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
305 => {
parser.sets[index].predict(State{rule: 761 ,left: 305 ,right:vec![ 34,213,129,130,90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
306 => {
parser.sets[index].predict(State{rule: 762 ,left: 306 ,right:vec![ 47 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 763 ,left: 306 ,right:vec![ 48 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 764 ,left: 306 ,right:vec![ 45 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 765 ,left: 306 ,right:vec![ 49 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 766 ,left: 306 ,right:vec![ 38 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 767 ,left: 306 ,right:vec![ 39 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 768 ,left: 306 ,right:vec![ 307 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
307 => {
parser.sets[index].predict(State{rule: 769 ,left: 307 ,right:vec![ 50 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 770 ,left: 307 ,right:vec![ 51 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 771 ,left: 307 ,right:vec![ 52 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 772 ,left: 307 ,right:vec![ 53 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
308 => {
parser.sets[index].predict(State{rule: 773 ,left: 308 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 774 ,left: 308 ,right:vec![ 309 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
309 => {
parser.sets[index].predict(State{rule: 775 ,left: 309 ,right:vec![ 57 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 776 ,left: 309 ,right:vec![ 40 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 777 ,left: 309 ,right:vec![ 18 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 778 ,left: 309 ,right:vec![ 9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
310 => {
parser.sets[index].predict(State{rule: 779 ,left: 310 ,right:vec![ 66 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 780 ,left: 310 ,right:vec![ 61 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 781 ,left: 310 ,right:vec![ 62 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 782 ,left: 310 ,right:vec![ 67 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 783 ,left: 310 ,right:vec![ 80 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 784 ,left: 310 ,right:vec![ 77 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 785 ,left: 310 ,right:vec![ 64 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 786 ,left: 310 ,right:vec![ 68 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 787 ,left: 310 ,right:vec![ 69 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 788 ,left: 310 ,right:vec![ 70 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 789 ,left: 310 ,right:vec![ 71 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 790 ,left: 310 ,right:vec![ 72 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 791 ,left: 310 ,right:vec![ 73 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 792 ,left: 310 ,right:vec![ 74 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 793 ,left: 310 ,right:vec![ 75 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 794 ,left: 310 ,right:vec![ 83 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 795 ,left: 310 ,right:vec![ 82 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 796 ,left: 310 ,right:vec![ 85 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 797 ,left: 310 ,right:vec![ 65 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 798 ,left: 310 ,right:vec![ 60 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 799 ,left: 310 ,right:vec![ 47 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 800 ,left: 310 ,right:vec![ 48 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 801 ,left: 310 ,right:vec![ 45 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 802 ,left: 310 ,right:vec![ 49 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 803 ,left: 310 ,right:vec![ 50 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 804 ,left: 310 ,right:vec![ 51 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 805 ,left: 310 ,right:vec![ 52 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 806 ,left: 310 ,right:vec![ 53 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 807 ,left: 310 ,right:vec![ 57 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 808 ,left: 310 ,right:vec![ 76 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 809 ,left: 310 ,right:vec![ 46 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 810 ,left: 310 ,right:vec![ 14 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 811 ,left: 310 ,right:vec![ 1 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 812 ,left: 310 ,right:vec![ 6 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 813 ,left: 310 ,right:vec![ 28 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 814 ,left: 310 ,right:vec![ 40 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 815 ,left: 310 ,right:vec![ 4 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 816 ,left: 310 ,right:vec![ 18 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 817 ,left: 310 ,right:vec![ 33 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 818 ,left: 310 ,right:vec![ 8 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 819 ,left: 310 ,right:vec![ 5 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 820 ,left: 310 ,right:vec![ 39 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 821 ,left: 310 ,right:vec![ 12 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 822 ,left: 310 ,right:vec![ 16 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 823 ,left: 310 ,right:vec![ 32 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 824 ,left: 310 ,right:vec![ 19 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 825 ,left: 310 ,right:vec![ 37 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 826 ,left: 310 ,right:vec![ 34 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 827 ,left: 310 ,right:vec![ 36 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 828 ,left: 310 ,right:vec![ 31 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 829 ,left: 310 ,right:vec![ 10 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 830 ,left: 310 ,right:vec![ 30 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 831 ,left: 310 ,right:vec![ 2 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 832 ,left: 310 ,right:vec![ 13 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 833 ,left: 310 ,right:vec![ 23 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 834 ,left: 310 ,right:vec![ 27 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 835 ,left: 310 ,right:vec![ 7 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 836 ,left: 310 ,right:vec![ 21 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 837 ,left: 310 ,right:vec![ 38 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 838 ,left: 310 ,right:vec![ 17 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 839 ,left: 310 ,right:vec![ 15 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 840 ,left: 310 ,right:vec![ 9 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 841 ,left: 310 ,right:vec![ 11 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 842 ,left: 310 ,right:vec![ 41 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 843 ,left: 310 ,right:vec![ 35 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 844 ,left: 310 ,right:vec![ 29 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 845 ,left: 310 ,right:vec![ 26 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 846 ,left: 310 ,right:vec![ 22 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 847 ,left: 310 ,right:vec![ 3 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 848 ,left: 310 ,right:vec![ 20 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 849 ,left: 310 ,right:vec![ 24 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 850 ,left: 310 ,right:vec![ 55 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 851 ,left: 310 ,right:vec![ 56 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 852 ,left: 310 ,right:vec![ 58 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 853 ,left: 310 ,right:vec![ 25 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 854 ,left: 310 ,right:vec![ 90 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 855 ,left: 310 ,right:vec![ 79 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 856 ,left: 310 ,right:vec![ 84 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 857 ,left: 310 ,right:vec![ 92 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 858 ,left: 310 ,right:vec![ 59 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 859 ,left: 310 ,right:vec![ 86 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 860 ,left: 310 ,right:vec![ 63 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 861 ,left: 310 ,right:vec![ 94 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 862 ,left: 310 ,right:vec![ 91 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 863 ,left: 310 ,right:vec![ 101 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 864 ,left: 310 ,right:vec![ 102 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 865 ,left: 310 ,right:vec![ 104 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 866 ,left: 310 ,right:vec![ 81 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 867 ,left: 310 ,right:vec![ 78 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 868 ,left: 310 ,right:vec![ 103 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 869 ,left: 310 ,right:vec![ 93 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 870 ,left: 310 ,right:vec![ 88 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 871 ,left: 310 ,right:vec![ 87 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 872 ,left: 310 ,right:vec![ 89 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
311 => {
parser.sets[index].predict(State{rule: 873 ,left: 311 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 874 ,left: 311 ,right:vec![ 311,312 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
312 => {
parser.sets[index].predict(State{rule: 875 ,left: 312 ,right:vec![ 313 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 876 ,left: 312 ,right:vec![ 310 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
313 => {
parser.sets[index].predict(State{rule: 877 ,left: 313 ,right:vec![ 314 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 878 ,left: 313 ,right:vec![ 315 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 879 ,left: 313 ,right:vec![ 316 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
314 => {
parser.sets[index].predict(State{rule: 880 ,left: 314 ,right:vec![ 97,311,98 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
315 => {
parser.sets[index].predict(State{rule: 881 ,left: 315 ,right:vec![ 99,311,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
316 => {
parser.sets[index].predict(State{rule: 882 ,left: 316 ,right:vec![ 95,311,96 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 3 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
317 => {
parser.sets[index].predict(State{rule: 883 ,left: 317 ,right:vec![ 54 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 884 ,left: 317 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
318 => {
parser.sets[index].predict(State{rule: 885 ,left: 318 ,right:vec![ 42,309,99,319,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 886 ,left: 318 ,right:vec![ 42,309,97,235,98,99,319,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
319 => {
parser.sets[index].predict(State{rule: 887 ,left: 319 ,right:vec![ 320 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 888 ,left: 319 ,right:vec![  ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 0 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
320 => {
parser.sets[index].predict(State{rule: 889 ,left: 320 ,right:vec![ 321 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 890 ,left: 320 ,right:vec![ 321,320 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 2 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
321 => {
parser.sets[index].predict(State{rule: 891 ,left: 321 ,right:vec![ 178 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 1 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
322 => {
parser.sets[index].predict(State{rule: 892 ,left: 322 ,right:vec![ 43,309,99,292,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 5 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
parser.sets[index].predict(State{rule: 893 ,left: 322 ,right:vec![ 43,309,97,235,98,99,292,100 ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; 8 ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),});
}
_ => panic!(""), } }//predict
fn compute_value(state:&mut State<Token>) { state.computed_value = match state.rule { 0 => state.values[0].clone(),
1 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::MaybeShebang,&Token::InnerAttrs,&Token::MaybeModItems(ref items)) => Token::WholeCrate(items.clone()),
_ => panic!(""), },
2 => match (&state.values[0],&state.values[1]) {
(&Token::MaybeShebang,&Token::MaybeModItems(ref items)) => Token::WholeCrate(items.clone()),
_ => panic!(""), },
3 => match &state.values[0] {
&Token::ShebangLine => Token::MaybeShebang,
_ => panic!(""), },
4 => match () {
() => Token::MaybeShebang,
_ => panic!(""), },
5 => match &state.values[0] {
&Token::InnerAttrs => Token::MaybeInnerAttrs,
_ => panic!(""), },
6 => match () {
() => Token::MaybeInnerAttrs,
_ => panic!(""), },
7 => match &state.values[0] {
&Token::InnerAttr => Token::InnerAttrs,
_ => panic!(""), },
8 => match (&state.values[0],&state.values[1]) {
(&Token::InnerAttrs,&Token::InnerAttr) => Token::InnerAttrs,
_ => panic!(""), },
9 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Shebang,&Token::LBracket,&Token::MetaItem(_),&Token::RBracket) => Token::InnerAttr,
_ => panic!(""), },
10 => match &state.values[0] {
&Token::InnerDocComment => Token::InnerAttr,
_ => panic!(""), },
11 => match &state.values[0] {
&Token::OuterAttrs(ref attrs) => Token::MaybeOuterAttrs(attrs.clone()),
_ => panic!(""), },
12 => match () {
() => Token::MaybeOuterAttrs(vec![]),
_ => panic!(""), },
13 => match &state.values[0] {
&Token::OuterAttr(ref kind) => Token::OuterAttrs(vec![kind.clone()]),
_ => panic!(""), },
14 => match (&state.values[0],&state.values[1]) {
(&Token::OuterAttrs(ref attrs),&Token::OuterAttr(ref attr)) => Token::OuterAttrs({let mut new  =  attrs.clone();
new.push(attr.clone());; new}),
_ => panic!(""), },
15 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::NumberSign,&Token::LBracket,&Token::MetaItem(ref attr),&Token::RBracket) => Token::OuterAttr(attr.clone()),
_ => panic!(""), },
16 => match &state.values[0] {
&Token::OuterDocComment(ref string) => Token::OuterAttr(AttrKind::Documentation(string.clone())),
_ => panic!(""), },
17 => match &state.values[0] {
&Token::Ident(ref string) => Token::MetaItem(AttrKind::Flag(string.clone())),
_ => panic!(""), },
18 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ident(ref string),&Token::Equal,&Token::Lit(ref lit)) => Token::MetaItem(AttrKind::Value(string.clone(),lit.clone())),
_ => panic!(""), },
19 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Ident(ref string),&Token::LPar,&Token::MetaSeq(ref seq),&Token::RPar) => Token::MetaItem(AttrKind::Sequence(string.clone(),seq.clone())),
_ => panic!(""), },
20 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Ident(ref string),&Token::LPar,&Token::MetaSeq(ref seq),&Token::Comma,&Token::RPar) => Token::MetaItem(AttrKind::Sequence(string.clone(),seq.clone())),
_ => panic!(""), },
21 => match () {
() => Token::MetaSeq(vec![]),
_ => panic!(""), },
22 => match &state.values[0] {
&Token::MetaItem(ref attr) => Token::MetaSeq(vec![attr.clone()]),
_ => panic!(""), },
23 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::MetaSeq(ref seq),&Token::Comma,&Token::MetaItem(ref attr)) => Token::MetaSeq({let mut new  =  seq.clone();
new.push(attr.clone());; new}),
_ => panic!(""), },
24 => match &state.values[0] {
&Token::ModItems(ref items) => Token::MaybeModItems(items.clone()),
_ => panic!(""), },
25 => match () {
() => Token::MaybeModItems(vec![]),
_ => panic!(""), },
26 => match &state.values[0] {
&Token::ModItem(ref outer,ref item) => Token::ModItems(vec![Rc::new(Token::ModItem(outer.clone(),item.clone()))]),
_ => panic!(""), },
27 => match (&state.values[0],&state.values[1]) {
(&Token::ModItems(ref items),&Token::ModItem(ref outer,ref item)) => Token::ModItems({let mut new  =  items.clone();
new.push(Rc::new(Token::ModItem(outer.clone(),item.clone())));; new}),
_ => panic!(""), },
28 => match (&state.values[0],&state.values[1]) {
(&Token::MaybeOuterAttrs(ref attrs),&Token::Visibility) => Token::AttrsAndVis(attrs.clone()),
_ => panic!(""), },
29 => match (&state.values[0],&state.values[1]) {
(&Token::AttrsAndVis(ref attrs),&Token::Item(ref item)) => Token::ModItem(attrs.clone(),item.clone()),
_ => panic!(""), },
30 => match &state.values[0] {
&Token::StmtItem(ref item) => Token::Item(item.clone()),
_ => panic!(""), },
31 => match &state.values[0] {
&Token::ItemMacro(ref item) => Token::Item(item.clone()),
_ => panic!(""), },
32 => match &state.values[0] {
&Token::ItemStatic => Token::StmtItem(ItemKind::Fixme),
_ => panic!(""), },
33 => match &state.values[0] {
&Token::ItemConst => Token::StmtItem(ItemKind::Fixme),
_ => panic!(""), },
34 => match &state.values[0] {
&Token::ItemType => Token::StmtItem(ItemKind::Fixme),
_ => panic!(""), },
35 => match &state.values[0] {
&Token::BlockItem(ref item) => Token::StmtItem(item.clone()),
_ => panic!(""), },
36 => match &state.values[0] {
&Token::ViewItem(ref view) => Token::StmtItem(ItemKind::View(view.clone())),
_ => panic!(""), },
37 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::Static,&Token::Ident(_),&Token::Colon,&Token::Ty(_),&Token::Equal,&Token::Expr(_),&Token::Semicolon) => Token::ItemStatic,
_ => panic!(""), },
38 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::Static,&Token::Mut,&Token::Ident(_),&Token::Colon,&Token::Ty(_),&Token::Equal,&Token::Expr(_),&Token::Semicolon) => Token::ItemStatic,
_ => panic!(""), },
39 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::Const,&Token::Ident(_),&Token::Colon,&Token::Ty(_),&Token::Equal,&Token::Semicolon) => Token::ItemConst,
_ => panic!(""), },
40 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::PathExpr(ref s),&Token::Bang,&Token::MaybeIdent,&Token::ParensDelimitedTokenTrees(ref trees),&Token::Semicolon) => Token::ItemMacro(ItemKind::Macro(Rc::new(Token::PathExpr(s.clone())),None,Rc::new(Token::ParensDelimitedTokenTrees(trees.clone())))),
_ => panic!(""), },
41 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathExpr(ref s),&Token::Bang,&Token::MaybeIdent,&Token::BracesDelimitedTokenTrees(ref trees)) => Token::ItemMacro(ItemKind::Macro(Rc::new(Token::PathExpr(s.clone())),None,Rc::new(Token::BracesDelimitedTokenTrees(trees.clone())))),
_ => panic!(""), },
42 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::PathExpr(ref s),&Token::Bang,&Token::MaybeIdent,&Token::BracketsDelimitedTokenTrees(ref trees),&Token::Semicolon) => Token::ItemMacro(ItemKind::Macro(Rc::new(Token::PathExpr(s.clone())),None,Rc::new(Token::BracketsDelimitedTokenTrees(trees.clone())))),
_ => panic!(""), },
43 => match &state.values[0] {
&Token::UseItem(ref view) => Token::ViewItem(view.clone()),
_ => panic!(""), },
44 => match &state.values[0] {
&Token::ExternFnItem => Token::ViewItem(ViewKind::Fixme),
_ => panic!(""), },
45 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Extern,&Token::Crate,&Token::Ident(ref string),&Token::Semicolon) => Token::ViewItem(ViewKind::ExternCrate(string.clone(),None)),
_ => panic!(""), },
46 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::Extern,&Token::Crate,&Token::Ident(ref string),&Token::As,&Token::Ident(ref string_as),&Token::Semicolon) => Token::ViewItem(ViewKind::ExternCrate(string.clone(),Some(string_as.clone()))),
_ => panic!(""), },
47 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Extern,&Token::MaybeAbi,&Token::ItemFn(_)) => Token::ExternFnItem,
_ => panic!(""), },
48 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Use,&Token::ViewPath(ref path),&Token::Semicolon) => Token::UseItem(path.clone()),
_ => panic!(""), },
49 => match &state.values[0] {
&Token::PathNoTypesAllowed(ref path) => Token::ViewPath(ViewKind::Path(path.clone(),None)),
_ => panic!(""), },
50 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathNoTypesAllowed(ref path),&Token::ModSep,&Token::LBrace,&Token::RBrace) => Token::ViewPath(ViewKind::Selection(Some(path.clone()),vec![])),
_ => panic!(""), },
51 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ModSep,&Token::LBrace,&Token::RBrace) => Token::ViewPath(ViewKind::Selection(None,vec![])),
_ => panic!(""), },
52 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::PathNoTypesAllowed(ref path),&Token::ModSep,&Token::LBrace,&Token::IdentsOrSelf(ref idents),&Token::RBrace) => Token::ViewPath(ViewKind::Selection(Some(path.clone()),idents.clone())),
_ => panic!(""), },
53 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::ModSep,&Token::LBrace,&Token::IdentsOrSelf(ref idents),&Token::RBrace) => Token::ViewPath(ViewKind::Selection(None,idents.clone())),
_ => panic!(""), },
54 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::PathNoTypesAllowed(ref path),&Token::ModSep,&Token::LBrace,&Token::IdentsOrSelf(ref idents),&Token::Comma,&Token::RBrace) => Token::ViewPath(ViewKind::Selection(Some(path.clone()),idents.clone())),
_ => panic!(""), },
55 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::ModSep,&Token::LBrace,&Token::IdentsOrSelf(ref idents),&Token::Comma,&Token::RBrace) => Token::ViewPath(ViewKind::Selection(None,idents.clone())),
_ => panic!(""), },
56 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PathNoTypesAllowed(ref path),&Token::ModSep,&Token::Star) => Token::ViewPath(ViewKind::All(Some(path.clone()))),
_ => panic!(""), },
57 => match (&state.values[0],&state.values[1]) {
(&Token::ModSep,&Token::Star) => Token::ViewPath(ViewKind::All(None)),
_ => panic!(""), },
58 => match &state.values[0] {
&Token::Star => Token::ViewPath(ViewKind::All(None)),
_ => panic!(""), },
59 => match (&state.values[0],&state.values[1]) {
(&Token::LBrace,&Token::RBrace) => Token::ViewPath(ViewKind::Selection(None,vec![])),
_ => panic!(""), },
60 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBrace,&Token::IdentsOrSelf(ref idents),&Token::RBrace) => Token::ViewPath(ViewKind::Selection(None,idents.clone())),
_ => panic!(""), },
61 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LBrace,&Token::IdentsOrSelf(ref idents),&Token::Comma,&Token::RBrace) => Token::ViewPath(ViewKind::Selection(None,idents.clone())),
_ => panic!(""), },
62 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PathNoTypesAllowed(ref path),&Token::As,&Token::Ident(ref string)) => Token::ViewPath(ViewKind::Path(path.clone(),Some(string.clone()))),
_ => panic!(""), },
63 => match &state.values[0] {
&Token::ItemFn(ref item) => Token::BlockItem(item.clone()),
_ => panic!(""), },
64 => match &state.values[0] {
&Token::ItemUnsafeFn => Token::BlockItem(ItemKind::Fixme),
_ => panic!(""), },
65 => match &state.values[0] {
&Token::ItemMod => Token::BlockItem(ItemKind::Fixme),
_ => panic!(""), },
66 => match &state.values[0] {
&Token::ItemForeignMod => Token::BlockItem(ItemKind::Fixme),
_ => panic!(""), },
67 => match &state.values[0] {
&Token::ItemStruct(ref item) => Token::BlockItem(item.clone()),
_ => panic!(""), },
68 => match &state.values[0] {
&Token::ItemEnum(ref item) => Token::BlockItem(item.clone()),
_ => panic!(""), },
69 => match &state.values[0] {
&Token::ItemUnion => Token::BlockItem(ItemKind::Fixme),
_ => panic!(""), },
70 => match &state.values[0] {
&Token::ItemTrait => Token::BlockItem(ItemKind::Fixme),
_ => panic!(""), },
71 => match &state.values[0] {
&Token::ItemImpl(ref item) => Token::BlockItem(item.clone()),
_ => panic!(""), },
72 => match &state.values[0] {
&Token::ItemTerminal(ref item) => Token::BlockItem(item.clone()),
_ => panic!(""), },
73 => match &state.values[0] {
&Token::ItemNonterminal(ref item) => Token::BlockItem(item.clone()),
_ => panic!(""), },
74 => match (&state.values[0],&state.values[1]) {
(&Token::Colon,&Token::TySum(ref qtype)) => Token::MaybeTyAscription(Some(qtype.clone())),
_ => panic!(""), },
75 => match () {
() => Token::MaybeTyAscription(None),
_ => panic!(""), },
76 => match (&state.values[0],&state.values[1]) {
(&Token::Equal,&Token::Expr(ref expr)) => Token::MaybeInitExpr(Some(expr.clone())),
_ => panic!(""), },
77 => match () {
() => Token::MaybeInitExpr(None),
_ => panic!(""), },
78 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Struct,&Token::Ident(ref name),&Token::GenericParams(ref lifetimes, ref gp),&Token::MaybeWhereClause,&Token::StructDeclArgs(ref fields)) =>
	Token::ItemStruct(ItemKind::Struct(name.clone(),lifetimes.clone(),gp.clone(),fields.clone())),
_ => panic!(""), },
79 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::Struct,&Token::Ident(_),&Token::GenericParams(_,_),&Token::StructTupleArgs,&Token::MaybeWhereClause,&Token::Semicolon) => Token::ItemStruct(ItemKind::Fixme),
_ => panic!(""), },
80 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Struct,&Token::Ident(_),&Token::GenericParams(_,_),&Token::MaybeWhereClause,&Token::Semicolon) => Token::ItemStruct(ItemKind::Fixme),
_ => panic!(""), },
81 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBrace,&Token::StructDeclFields(ref fields),&Token::RBrace) => Token::StructDeclArgs(fields.clone()),
_ => panic!(""), },
82 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LBrace,&Token::StructDeclFields(ref fields),&Token::RBrace,&Token::Comma) => Token::StructDeclArgs(fields.clone()),
_ => panic!(""), },
83 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::StructTupleFields,&Token::RPar) => Token::StructTupleArgs,
_ => panic!(""), },
84 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LPar,&Token::StructTupleFields,&Token::RPar,&Token::Comma) => Token::StructTupleArgs,
_ => panic!(""), },
85 => match &state.values[0] {
&Token::StructDeclField(ref string, ref t) => Token::StructDeclFields(vec![(string.clone(),t.clone())]),
_ => panic!(""), },
86 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::StructDeclFields(ref list),&Token::Comma,&Token::StructDeclField(ref string, ref t)) =>
{
	let mut new=list.clone();
	new.push((string.clone(),t.clone()));
	Token::StructDeclFields(new)
},
_ => panic!(""), },
87 => match () {
() => Token::StructDeclFields(vec![]),
_ => panic!(""), },
88 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::AttrsAndVis(_),&Token::Ident(ref string),&Token::Colon,&Token::TySum(ref t)) => Token::StructDeclField(string.clone(),t.clone()),
_ => panic!(""), },
89 => match &state.values[0] {
&Token::StructTupleField => Token::StructTupleFields,
_ => panic!(""), },
90 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::StructTupleFields,&Token::Comma,&Token::StructTupleField) => Token::StructTupleFields,
_ => panic!(""), },
91 => match () {
() => Token::StructTupleFields,
_ => panic!(""), },
92 => match (&state.values[0],&state.values[1]) {
(&Token::AttrsAndVis(_),&Token::TySum(_)) => Token::StructTupleField,
_ => panic!(""), },
93 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::Enum,&Token::Ident(ref id),&Token::GenericParams(ref lifetimes,ref params),&Token::MaybeWhereClause,&Token::LBrace,&Token::EnumDefs(ref defs),&Token::RBrace) => Token::ItemEnum(ItemKind::Enum(id.clone(),lifetimes.clone(),params.clone(),defs.clone())),
_ => panic!(""), },
94 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::Enum,&Token::Ident(ref id),&Token::GenericParams(ref lifetimes, ref params),&Token::MaybeWhereClause,&Token::LBrace,&Token::EnumDefs(ref defs),&Token::RBrace,&Token::Comma) =>
	Token::ItemEnum(ItemKind::Enum(id.clone(),lifetimes.clone(),params.clone(),defs.clone())),
_ => panic!(""), },
95 => match &state.values[0] {
&Token::EnumDef(ref id, ref arguments) => Token::EnumDefs(vec![(id.clone(),arguments.clone())]),
_ => panic!(""), },
96 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::EnumDefs(ref list),&Token::Comma,&Token::EnumDef(ref id, ref arguments)) =>
{
	let mut new=list.clone();
	new.push((id.clone(),arguments.clone()));
	Token::EnumDefs(new)
},
_ => panic!(""), },
97 => match () {
() => Token::EnumDefs(vec![]),
_ => panic!(""), },
98 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::AttrsAndVis(_),&Token::Ident(ref string),&Token::EnumArgs(ref arguments)) => Token::EnumDef(string.clone(),arguments.clone()),
_ => panic!(""), },
99 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBrace,&Token::StructDeclFields(_),&Token::RBrace) => Token::EnumArgs(vec![]),
_ => panic!(""), },
100 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LBrace,&Token::StructDeclFields(_),&Token::Comma,&Token::RBrace) => Token::EnumArgs(vec![]),
_ => panic!(""), },
101 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::MaybeTySums(ref list),&Token::RPar) => Token::EnumArgs(list.clone()),
_ => panic!(""), },
102 => match (&state.values[0],&state.values[1]) {
(&Token::Equal,&Token::Expr(_)) => Token::EnumArgs(vec![]),
_ => panic!(""), },
103 => match () {
() => Token::EnumArgs(vec![]),
_ => panic!(""), },
104 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::Union,&Token::Ident(_),&Token::GenericParams(_,_),&Token::MaybeWhereClause,&Token::LBrace,&Token::StructDeclFields(_),&Token::RBrace) => Token::ItemUnion,
_ => panic!(""), },
105 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::Union,&Token::Ident(_),&Token::GenericParams(_,_),&Token::MaybeWhereClause,&Token::LBrace,&Token::StructDeclFields(_),&Token::Comma,&Token::RBrace) => Token::ItemUnion,
_ => panic!(""), },
106 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Mod,&Token::Ident(_),&Token::Semicolon) => Token::ItemMod,
_ => panic!(""), },
107 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Mod,&Token::Ident(_),&Token::LBrace,&Token::MaybeModItems(_),&Token::RBrace) => Token::ItemMod,
_ => panic!(""), },
108 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::Mod,&Token::Ident(_),&Token::LBrace,&Token::InnerAttrs,&Token::MaybeModItems(_),&Token::RBrace) => Token::ItemMod,
_ => panic!(""), },
109 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Extern,&Token::MaybeAbi,&Token::LBrace,&Token::MaybeForeignItems,&Token::RBrace) => Token::ItemForeignMod,
_ => panic!(""), },
110 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::Extern,&Token::MaybeAbi,&Token::LBrace,&Token::InnerAttrs,&Token::MaybeForeignItems,&Token::RBrace) => Token::ItemForeignMod,
_ => panic!(""), },
111 => match &state.values[0] {
&Token::Str(_) => Token::MaybeAbi,
_ => panic!(""), },
112 => match () {
() => Token::MaybeAbi,
_ => panic!(""), },
113 => match &state.values[0] {
&Token::ForeignItems => Token::MaybeForeignItems,
_ => panic!(""), },
114 => match () {
() => Token::MaybeForeignItems,
_ => panic!(""), },
115 => match &state.values[0] {
&Token::ForeignItem => Token::ForeignItems,
_ => panic!(""), },
116 => match (&state.values[0],&state.values[1]) {
(&Token::ForeignItems,&Token::ForeignItem) => Token::ForeignItems,
_ => panic!(""), },
117 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::AttrsAndVis(_),&Token::Static,&Token::ItemForeignStatic) => Token::ForeignItem,
_ => panic!(""), },
118 => match (&state.values[0],&state.values[1]) {
(&Token::AttrsAndVis(_),&Token::ItemForeignFn) => Token::ForeignItem,
_ => panic!(""), },
119 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::AttrsAndVis(_),&Token::Unsafe,&Token::ItemForeignFn) => Token::ForeignItem,
_ => panic!(""), },
120 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::MaybeMut(_),&Token::Ident(_),&Token::Colon,&Token::Ty(_),&Token::Semicolon) => Token::ItemForeignStatic,
_ => panic!(""), },
121 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDeclAllowVariadic,&Token::MaybeWhereClause,&Token::Semicolon) => Token::ItemForeignFn,
_ => panic!(""), },
122 => match (&state.values[0],&state.values[1]) {
(&Token::FnParamsAllowVariadic,&Token::RetTy(_)) => Token::FnDeclAllowVariadic,
_ => panic!(""), },
123 => match (&state.values[0],&state.values[1]) {
(&Token::LPar,&Token::RPar) => Token::FnParamsAllowVariadic,
_ => panic!(""), },
124 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::Params(_),&Token::RPar) => Token::FnParamsAllowVariadic,
_ => panic!(""), },
125 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LPar,&Token::Params(_),&Token::Comma,&Token::RPar) => Token::FnParamsAllowVariadic,
_ => panic!(""), },
126 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::LPar,&Token::Params(_),&Token::Comma,&Token::DotDotDot,&Token::RPar) => Token::FnParamsAllowVariadic,
_ => panic!(""), },
127 => match &state.values[0] {
&Token::Pub => Token::Visibility,
_ => panic!(""), },
128 => match () {
() => Token::Visibility,
_ => panic!(""), },
129 => match &state.values[0] {
&Token::IdentOrSelf(ref string) => Token::IdentsOrSelf(vec![string.clone()]),
_ => panic!(""), },
130 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::IdentsOrSelf(ref list),&Token::As,&Token::Ident(_)) => Token::IdentsOrSelf(list.clone()),
_ => panic!(""), },
131 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::IdentsOrSelf(ref list),&Token::Comma,&Token::IdentOrSelf(ref string)) =>
{
	let mut new=list.clone();
	new.push(string.clone());
	Token::IdentsOrSelf(new)
},
_ => panic!(""), },
132 => match &state.values[0] {
&Token::Ident(ref string) => Token::IdentOrSelf(string.clone()),
_ => panic!(""), },
133 => match &state.values[0] {
&Token::LittleSelf => Token::IdentOrSelf(String::from("self")),
_ => panic!(""), },
134 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::Type,&Token::Ident(_),&Token::GenericParams(_,_),&Token::MaybeWhereClause,&Token::Equal,&Token::TySum(_),&Token::Semicolon) => Token::ItemType,
_ => panic!(""), },
135 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::For,&Token::QuestionMark,&Token::Ident(_)) => Token::ForSized,
_ => panic!(""), },
136 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::For,&Token::Ident(_),&Token::QuestionMark) => Token::ForSized,
_ => panic!(""), },
137 => match () {
() => Token::ForSized,
_ => panic!(""), },
138 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8],&state.values[9]) {
(&Token::MaybeUnsafe,&Token::Trait,&Token::Ident(_),&Token::GenericParams(_,_),&Token::ForSized,&Token::MaybeTyParamBounds,&Token::MaybeWhereClause,&Token::LBrace,&Token::MaybeTraitItems,&Token::RBrace) => Token::ItemTrait,
_ => panic!(""), },
139 => match &state.values[0] {
&Token::TraitItems => Token::MaybeTraitItems,
_ => panic!(""), },
140 => match () {
() => Token::MaybeTraitItems,
_ => panic!(""), },
141 => match &state.values[0] {
&Token::TraitItem => Token::TraitItems,
_ => panic!(""), },
142 => match (&state.values[0],&state.values[1]) {
(&Token::TraitItems,&Token::TraitItem) => Token::TraitItems,
_ => panic!(""), },
143 => match &state.values[0] {
&Token::TraitConst => Token::TraitItem,
_ => panic!(""), },
144 => match &state.values[0] {
&Token::TraitType => Token::TraitItem,
_ => panic!(""), },
145 => match &state.values[0] {
&Token::TraitMethod => Token::TraitItem,
_ => panic!(""), },
146 => match (&state.values[0],&state.values[1]) {
(&Token::MaybeOuterAttrs(_),&Token::ItemMacro(_)) => Token::TraitItem,
_ => panic!(""), },
147 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::MaybeOuterAttrs(_),&Token::Const,&Token::Ident(_),&Token::MaybeTyAscription(_),&Token::MaybeConstDefault,&Token::Semicolon) => Token::TraitConst,
_ => panic!(""), },
148 => match (&state.values[0],&state.values[1]) {
(&Token::Equal,&Token::Expr(_)) => Token::MaybeConstDefault,
_ => panic!(""), },
149 => match () {
() => Token::MaybeConstDefault,
_ => panic!(""), },
150 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::MaybeOuterAttrs(_),&Token::Type,&Token::TyParam(_),&Token::Semicolon) => Token::TraitType,
_ => panic!(""), },
151 => match &state.values[0] {
&Token::Unsafe => Token::MaybeUnsafe,
_ => panic!(""), },
152 => match () {
() => Token::MaybeUnsafe,
_ => panic!(""), },
153 => match (&state.values[0],&state.values[1]) {
(&Token::DEFAULT,&Token::Unsafe) => Token::MaybeDefaultMaybeUnsafe,
_ => panic!(""), },
154 => match &state.values[0] {
&Token::Unsafe => Token::MaybeDefaultMaybeUnsafe,
_ => panic!(""), },
155 => match &state.values[0] {
&Token::Unsafe => Token::MaybeDefaultMaybeUnsafe,
_ => panic!(""), },
156 => match () {
() => Token::MaybeDefaultMaybeUnsafe,
_ => panic!(""), },
157 => match &state.values[0] {
&Token::TypeMethod => Token::TraitMethod,
_ => panic!(""), },
158 => match &state.values[0] {
&Token::Method => Token::TraitMethod,
_ => panic!(""), },
159 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::MaybeOuterAttrs(_),&Token::MaybeUnsafe,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDeclWithSelfAllowAnonParams,&Token::MaybeWhereClause,&Token::Semicolon) => Token::TypeMethod,
_ => panic!(""), },
160 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8]) {
(&Token::MaybeOuterAttrs(_),&Token::Const,&Token::MaybeUnsafe,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDeclWithSelfAllowAnonParams,&Token::MaybeWhereClause,&Token::Semicolon) => Token::TypeMethod,
_ => panic!(""), },
161 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8],&state.values[9]) {
(&Token::MaybeOuterAttrs(_),&Token::MaybeUnsafe,&Token::Extern,&Token::MaybeAbi,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDeclWithSelfAllowAnonParams,&Token::MaybeWhereClause,&Token::Semicolon) => Token::TypeMethod,
_ => panic!(""), },
162 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::MaybeOuterAttrs(_),&Token::MaybeUnsafe,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDeclWithSelfAllowAnonParams,&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(_,_)) => Token::Method,
_ => panic!(""), },
163 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8]) {
(&Token::MaybeOuterAttrs(_),&Token::Const,&Token::MaybeUnsafe,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDeclWithSelfAllowAnonParams,&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(_,_)) => Token::Method,
_ => panic!(""), },
164 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8],&state.values[9]) {
(&Token::MaybeOuterAttrs(_),&Token::MaybeUnsafe,&Token::Extern,&Token::MaybeAbi,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDeclWithSelfAllowAnonParams,&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(_,_)) => Token::Method,
_ => panic!(""), },
165 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8]) {
(&Token::AttrsAndVis(_),&Token::MaybeDefault,&Token::MaybeUnsafe,&Token::FN,&Token::Ident(ref name),&Token::GenericParams(ref lifetimes, ref gp),&Token::FnDeclWithSelf(has_self, has_ref, has_mut, ref ot_self, ref params, ref oret),&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(ref stmts,ref be)) =>
	Token::ImplMethod(ItemKind::Method(name.clone(),lifetimes.clone(),gp.clone(),has_self,has_ref,has_mut,ot_self.clone(),params.clone(),oret.clone(),stmts.clone(),be.clone())),
_ => panic!(""), },
166 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8],&state.values[9]) {
(&Token::AttrsAndVis(_),&Token::MaybeDefault,&Token::Const,&Token::MaybeUnsafe,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDeclWithSelf(_,_,_,_,_,_),&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(_,_)) => Token::ImplMethod(ItemKind::Fixme),
_ => panic!(""), },
167 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8],&state.values[9],&state.values[10]) {
(&Token::AttrsAndVis(_),&Token::MaybeDefault,&Token::MaybeUnsafe,&Token::Extern,&Token::MaybeAbi,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDeclWithSelf(_,_,_,_,_,_),&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(_,_)) => Token::ImplMethod(ItemKind::Fixme),
_ => panic!(""), },
168 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8]) {
(&Token::MaybeDefaultMaybeUnsafe,&Token::Impl,&Token::GenericParams(ref lifetimes,ref gp),&Token::TyPrimSum(ref t),&Token::MaybeWhereClause,&Token::LBrace,&Token::MaybeInnerAttrs,&Token::MaybeImplItems(ref items),&Token::RBrace) => Token::ItemImpl(ItemKind::Impl(lifetimes.clone(),gp.clone(),None,t.clone(),items.clone())),
_ => panic!(""), },
169 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8],&state.values[9],&state.values[10]) {
(&Token::MaybeDefaultMaybeUnsafe,&Token::Impl,&Token::GenericParams(_,_),&Token::LPar,&Token::Ty(_),&Token::RPar,&Token::MaybeWhereClause,&Token::LBrace,&Token::MaybeInnerAttrs,&Token::MaybeImplItems(_),&Token::RBrace) => Token::ItemImpl(ItemKind::Fixme),
_ => panic!(""), },
170 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8],&state.values[9],&state.values[10]) {
(&Token::MaybeDefaultMaybeUnsafe,&Token::Impl,&Token::GenericParams(ref lifetimes, ref gp),&Token::TraitRef(ref path),&Token::For,&Token::TySum(ref t),&Token::MaybeWhereClause,&Token::LBrace,&Token::MaybeInnerAttrs,&Token::MaybeImplItems(ref items),&Token::RBrace) =>
	Token::ItemImpl(ItemKind::Impl(lifetimes.clone(),gp.clone(),Some(path.clone()),t.clone(),items.clone())),
_ => panic!(""), },
171 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8],&state.values[9],&state.values[10],&state.values[11]) {
(&Token::MaybeDefaultMaybeUnsafe,&Token::Impl,&Token::GenericParams(_,_),&Token::Bang,&Token::TraitRef(_),&Token::For,&Token::TySum(_),&Token::MaybeWhereClause,&Token::LBrace,&Token::MaybeInnerAttrs,&Token::MaybeImplItems(_),&Token::RBrace) => Token::ItemImpl(ItemKind::Fixme),
_ => panic!(""), },
172 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::MaybeDefaultMaybeUnsafe,&Token::Impl,&Token::GenericParams(_,_),&Token::TraitRef(_),&Token::For,&Token::DotDot,&Token::LBrace,&Token::RBrace) => Token::ItemImpl(ItemKind::Fixme),
_ => panic!(""), },
173 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8]) {
(&Token::MaybeDefaultMaybeUnsafe,&Token::Impl,&Token::GenericParams(_,_),&Token::Bang,&Token::TraitRef(_),&Token::For,&Token::DotDot,&Token::LBrace,&Token::RBrace) => Token::ItemImpl(ItemKind::Fixme),
_ => panic!(""), },
174 => match &state.values[0] {
&Token::ImplItems(ref items) => Token::MaybeImplItems(items.clone()),
_ => panic!(""), },
175 => match () {
() => Token::MaybeImplItems(vec![]),
_ => panic!(""), },
176 => match &state.values[0] {
&Token::ImplItem(ref item) => Token::ImplItems(vec![item.clone()]),
_ => panic!(""), },
177 => match (&state.values[0],&state.values[1]) {
(&Token::ImplItem(ref item),&Token::ImplItems(ref list)) =>
{
	let mut new=vec![item.clone()];
	//new.extend(list);
	new.extend(list.iter().map( |x|(x.clone()) ));
	Token::ImplItems(new)
},
_ => panic!(""), },
178 => match &state.values[0] {
&Token::ImplMethod(ref item) => Token::ImplItem(item.clone()),
_ => panic!(""), },
179 => match (&state.values[0],&state.values[1]) {
(&Token::AttrsAndVis(_),&Token::ItemMacro(_)) => Token::ImplItem(ItemKind::Fixme),
_ => panic!(""), },
180 => match &state.values[0] {
&Token::ImplConst => Token::ImplItem(ItemKind::Fixme),
_ => panic!(""), },
181 => match &state.values[0] {
&Token::ImplType => Token::ImplItem(ItemKind::Fixme),
_ => panic!(""), },
182 => match &state.values[0] {
&Token::DEFAULT => Token::MaybeDefault,
_ => panic!(""), },
183 => match () {
() => Token::MaybeDefault,
_ => panic!(""), },
184 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::AttrsAndVis(_),&Token::MaybeDefault,&Token::ItemConst) => Token::ImplConst,
_ => panic!(""), },
185 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::AttrsAndVis(_),&Token::MaybeDefault,&Token::Type,&Token::Ident(_),&Token::GenericParams(_,_),&Token::Equal,&Token::TySum(_),&Token::Semicolon) => Token::ImplType,
_ => panic!(""), },
186 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::FN,&Token::Ident(ref name),&Token::GenericParams(ref lives, ref gp),&Token::FnDecl(ref params,ref rt),&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(ref block_stmts, ref block_expr)) => Token::ItemFn(ItemKind::FN(name.clone(),lives.clone(),gp.clone(),params.clone(),rt.clone(),block_stmts.clone(),block_expr.clone())),
_ => panic!(""), },
187 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::Const,&Token::FN,&Token::Ident(ref name),&Token::GenericParams(ref lives, ref gp),&Token::FnDecl(ref params,ref rt),&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(ref block_stmts, ref block_expr)) =>
	Token::ItemFn(ItemKind::FN(name.clone(),lives.clone(),gp.clone(),params.clone(),rt.clone(),block_stmts.clone(),block_expr.clone())),
_ => panic!(""), },
188 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::Unsafe,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDecl(_,_),&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(_,_)) => Token::ItemUnsafeFn,
_ => panic!(""), },
189 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::Const,&Token::Unsafe,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDecl(_,_),&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(_,_)) => Token::ItemUnsafeFn,
_ => panic!(""), },
190 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7],&state.values[8]) {
(&Token::Unsafe,&Token::Extern,&Token::MaybeAbi,&Token::FN,&Token::Ident(_),&Token::GenericParams(_,_),&Token::FnDecl(_,_),&Token::MaybeWhereClause,&Token::InnerAttrsAndBlock(_,_)) => Token::ItemUnsafeFn,
_ => panic!(""), },
191 => match (&state.values[0],&state.values[1]) {
(&Token::FnParams(ref params),&Token::RetTy(ref ot)) => Token::FnDecl(params.clone(),ot.clone()),
_ => panic!(""), },
192 => match (&state.values[0],&state.values[1]) {
(&Token::FnParamsWithSelf(has_self, has_ref, has_mut, ref ot_self, ref params),&Token::RetTy(ref oret)) => Token::FnDeclWithSelf(has_self,has_ref,has_mut,ot_self.clone(),params.clone(),oret.clone()),
_ => panic!(""), },
193 => match (&state.values[0],&state.values[1]) {
(&Token::FnAnonParamsWithSelf,&Token::RetTy(_)) => Token::FnDeclWithSelfAllowAnonParams,
_ => panic!(""), },
194 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::MaybeParams(ref params),&Token::RPar) => Token::FnParams(params.clone()),
_ => panic!(""), },
195 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LPar,&Token::AnonParam,&Token::AnonParamsAllowVariadicTail,&Token::RPar) => Token::FnAnonParams,
_ => panic!(""), },
196 => match (&state.values[0],&state.values[1]) {
(&Token::LPar,&Token::RPar) => Token::FnAnonParams,
_ => panic!(""), },
197 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::LPar,&Token::MaybeMut(ismut),&Token::LittleSelf,&Token::MaybeTyAscription(ref ot),&Token::MaybeCommaParams(ref params),&Token::RPar) =>
	Token::FnParamsWithSelf(true,false,ismut,ot.clone(),params.clone()),
_ => panic!(""), },
198 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::LPar,&Token::Ampersand,&Token::MaybeMut(ismut),&Token::LittleSelf,&Token::MaybeTyAscription(ref ot),&Token::MaybeCommaParams(ref params),&Token::RPar) =>
	Token::FnParamsWithSelf(true,true,ismut,ot.clone(),params.clone()),
_ => panic!(""), },
199 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::LPar,&Token::Ampersand,&Token::Lifetime(_),&Token::MaybeMut(ismut),&Token::LittleSelf,&Token::MaybeTyAscription(ref ot),&Token::MaybeCommaParams(ref params),&Token::RPar) => 
	Token::FnParamsWithSelf(true,true,ismut,ot.clone(),params.clone()),
_ => panic!(""), },
200 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::MaybeParams(ref params),&Token::RPar) => Token::FnParamsWithSelf(false,false,false,None,params.clone()),
_ => panic!(""), },
201 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::LPar,&Token::MaybeMut(_),&Token::LittleSelf,&Token::MaybeTyAscription(_),&Token::MaybeCommaAnonParams,&Token::RPar) => Token::FnAnonParamsWithSelf,
_ => panic!(""), },
202 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::LPar,&Token::Ampersand,&Token::MaybeMut(_),&Token::LittleSelf,&Token::MaybeTyAscription(_),&Token::MaybeCommaAnonParams,&Token::RPar) => Token::FnAnonParamsWithSelf,
_ => panic!(""), },
203 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::LPar,&Token::Ampersand,&Token::Lifetime(_),&Token::MaybeMut(_),&Token::LittleSelf,&Token::MaybeTyAscription(_),&Token::MaybeCommaAnonParams,&Token::RPar) => Token::FnAnonParamsWithSelf,
_ => panic!(""), },
204 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::MaybeAnonParams,&Token::RPar) => Token::FnAnonParamsWithSelf,
_ => panic!(""), },
205 => match &state.values[0] {
&Token::Params(ref params) => Token::MaybeParams(params.clone()),
_ => panic!(""), },
206 => match (&state.values[0],&state.values[1]) {
(&Token::Params(ref params),&Token::Comma) => Token::MaybeParams(params.clone()),
_ => panic!(""), },
207 => match () {
() => Token::MaybeParams(vec![]),
_ => panic!(""), },
208 => match &state.values[0] {
&Token::Param(ref pattern, ref t) => Token::Params(vec![(pattern.clone(),t.clone())]),
_ => panic!(""), },
209 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Params(ref list),&Token::Comma,&Token::Param(ref pattern,ref t)) =>
{
	let mut new=list.clone();
	new.push((pattern.clone(),t.clone()));
	Token::Params(new)
},
_ => panic!(""), },
210 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Pat(ref pattern),&Token::Colon,&Token::TySum(ref t)) => Token::Param(pattern.clone(),t.clone()),
_ => panic!(""), },
211 => match &state.values[0] {
&Token::InferrableParam(ref pattern, ref ot) => Token::InferrableParams(vec![(pattern.clone(),ot.clone())]),
_ => panic!(""), },
212 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::InferrableParams(ref params),&Token::Comma,&Token::InferrableParam(ref pattern, ref ot)) =>
{
	let mut new=params.clone();
	new.push((pattern.clone(),ot.clone()));
	Token::InferrableParams(new)
},
_ => panic!(""), },
213 => match (&state.values[0],&state.values[1]) {
(&Token::Pat(ref pat),&Token::MaybeTyAscription(ref ot)) => Token::InferrableParam(pat.clone(),ot.clone()),
_ => panic!(""), },
214 => match &state.values[0] {
&Token::Comma => Token::MaybeCommaParams(vec![]),
_ => panic!(""), },
215 => match (&state.values[0],&state.values[1]) {
(&Token::Comma,&Token::Params(ref params)) => Token::MaybeCommaParams(params.clone()),
_ => panic!(""), },
216 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Comma,&Token::Params(ref params),&Token::Comma) => Token::MaybeCommaParams(params.clone()),
_ => panic!(""), },
217 => match () {
() => Token::MaybeCommaParams(vec![]),
_ => panic!(""), },
218 => match &state.values[0] {
&Token::Comma => Token::MaybeCommaAnonParams,
_ => panic!(""), },
219 => match (&state.values[0],&state.values[1]) {
(&Token::Comma,&Token::AnonParams) => Token::MaybeCommaAnonParams,
_ => panic!(""), },
220 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Comma,&Token::AnonParams,&Token::Comma) => Token::MaybeCommaAnonParams,
_ => panic!(""), },
221 => match () {
() => Token::MaybeCommaAnonParams,
_ => panic!(""), },
222 => match &state.values[0] {
&Token::AnonParams => Token::MaybeAnonParams,
_ => panic!(""), },
223 => match (&state.values[0],&state.values[1]) {
(&Token::AnonParams,&Token::Comma) => Token::MaybeAnonParams,
_ => panic!(""), },
224 => match () {
() => Token::MaybeAnonParams,
_ => panic!(""), },
225 => match &state.values[0] {
&Token::AnonParam => Token::AnonParams,
_ => panic!(""), },
226 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::AnonParams,&Token::Comma,&Token::AnonParam) => Token::AnonParams,
_ => panic!(""), },
227 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NamedArg,&Token::Colon,&Token::Ty(_)) => Token::AnonParam,
_ => panic!(""), },
228 => match &state.values[0] {
&Token::Ty(_) => Token::AnonParam,
_ => panic!(""), },
229 => match (&state.values[0],&state.values[1]) {
(&Token::Comma,&Token::DotDotDot) => Token::AnonParamsAllowVariadicTail,
_ => panic!(""), },
230 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Comma,&Token::AnonParam,&Token::AnonParamsAllowVariadicTail) => Token::AnonParamsAllowVariadicTail,
_ => panic!(""), },
231 => match () {
() => Token::AnonParamsAllowVariadicTail,
_ => panic!(""), },
232 => match &state.values[0] {
&Token::Ident(_) => Token::NamedArg,
_ => panic!(""), },
233 => match &state.values[0] {
&Token::Underscore => Token::NamedArg,
_ => panic!(""), },
234 => match (&state.values[0],&state.values[1]) {
(&Token::Ampersand,&Token::Ident(_)) => Token::NamedArg,
_ => panic!(""), },
235 => match (&state.values[0],&state.values[1]) {
(&Token::Ampersand,&Token::Underscore) => Token::NamedArg,
_ => panic!(""), },
236 => match (&state.values[0],&state.values[1]) {
(&Token::AndAnd,&Token::Ident(_)) => Token::NamedArg,
_ => panic!(""), },
237 => match (&state.values[0],&state.values[1]) {
(&Token::AndAnd,&Token::Underscore) => Token::NamedArg,
_ => panic!(""), },
238 => match (&state.values[0],&state.values[1]) {
(&Token::Mut,&Token::Ident(_)) => Token::NamedArg,
_ => panic!(""), },
239 => match (&state.values[0],&state.values[1]) {
(&Token::RArrow,&Token::Bang) => Token::RetTy(Some(TyKind::Fixme)),
_ => panic!(""), },
240 => match (&state.values[0],&state.values[1]) {
(&Token::RArrow,&Token::Ty(ref t)) => Token::RetTy(Some(t.clone())),
_ => panic!(""), },
241 => match () {
() => Token::RetTy(None),
_ => panic!(""), },
242 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LT,&Token::GT,&Token::MaybeSpace) => Token::GenericParams(vec![],vec![]),
_ => panic!(""), },
243 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LT,&Token::Lifetimes(ref lives),&Token::GT,&Token::MaybeSpace) => Token::GenericParams(lives.clone(),vec![]),
_ => panic!(""), },
244 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::LT,&Token::Lifetimes(ref lives),&Token::Comma,&Token::GT,&Token::MaybeSpace) => Token::GenericParams(lives.clone(),vec![]),
_ => panic!(""), },
245 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::LT,&Token::Lifetimes(ref lives),&Token::Comma,&Token::TyParams(ref params),&Token::GT,&Token::MaybeSpace) => Token::GenericParams(lives.clone(),params.clone()),
_ => panic!(""), },
246 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::LT,&Token::Lifetimes(ref lives),&Token::Comma,&Token::TyParams(ref params),&Token::Comma,&Token::GT,&Token::MaybeSpace) => Token::GenericParams(lives.clone(),params.clone()),
_ => panic!(""), },
247 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LT,&Token::TyParams(ref params),&Token::GT) => Token::GenericParams(vec![],params.clone()),
_ => panic!(""), },
248 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LT,&Token::TyParams(ref params),&Token::Comma,&Token::GT) => Token::GenericParams(vec![],params.clone()),
_ => panic!(""), },
249 => match () {
() => Token::GenericParams(vec![],vec![]),
_ => panic!(""), },
250 => match () {
() => Token::MaybeWhereClause,
_ => panic!(""), },
251 => match &state.values[0] {
&Token::WhereClause => Token::MaybeWhereClause,
_ => panic!(""), },
252 => match (&state.values[0],&state.values[1]) {
(&Token::Where,&Token::WherePredicates) => Token::WhereClause,
_ => panic!(""), },
253 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Where,&Token::WherePredicates,&Token::Comma) => Token::WhereClause,
_ => panic!(""), },
254 => match &state.values[0] {
&Token::WherePredicate => Token::WherePredicates,
_ => panic!(""), },
255 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::WherePredicates,&Token::Comma,&Token::WherePredicate) => Token::WherePredicates,
_ => panic!(""), },
256 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::MaybeForLifetimes,&Token::Lifetime(_),&Token::Colon,&Token::Bounds) => Token::WherePredicate,
_ => panic!(""), },
257 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::MaybeForLifetimes,&Token::Ty(_),&Token::Colon,&Token::TyParamBounds) => Token::WherePredicate,
_ => panic!(""), },
258 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::For,&Token::LT,&Token::Lifetimes(_),&Token::GT) => Token::MaybeForLifetimes,
_ => panic!(""), },
259 => match () {
() => Token::MaybeForLifetimes,
_ => panic!(""), },
260 => match &state.values[0] {
&Token::TyParam(ref param) => Token::TyParams(vec![param.clone()]),
_ => panic!(""), },
261 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::TyParams(ref list),&Token::Comma,&Token::TyParam(ref param)) =>
{
	let mut new=list.clone();
	new.push(param.clone());
	Token::TyParams(new)
},
_ => panic!(""), },
262 => match &state.values[0] {
&Token::Ident(ref string) => Token::PathNoTypesAllowed(PathNKind::Ident(string.clone())),
_ => panic!(""), },
263 => match (&state.values[0],&state.values[1]) {
(&Token::ModSep,&Token::Ident(ref string)) => Token::PathNoTypesAllowed(PathNKind::AbsoluteIdent(string.clone())),
_ => panic!(""), },
264 => match &state.values[0] {
&Token::LittleSelf => Token::PathNoTypesAllowed(PathNKind::FromSelf),
_ => panic!(""), },
265 => match (&state.values[0],&state.values[1]) {
(&Token::ModSep,&Token::LittleSelf) => Token::PathNoTypesAllowed(PathNKind::AbsoluteSelf),
_ => panic!(""), },
266 => match &state.values[0] {
&Token::Super => Token::PathNoTypesAllowed(PathNKind::Super),
_ => panic!(""), },
267 => match (&state.values[0],&state.values[1]) {
(&Token::ModSep,&Token::Super) => Token::PathNoTypesAllowed(PathNKind::AbsoluteSuper),
_ => panic!(""), },
268 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PathNoTypesAllowed(ref path),&Token::ModSep,&Token::Ident(ref string)) => Token::PathNoTypesAllowed(PathNKind::Step(Rc::new(path.clone()),string.clone())),
_ => panic!(""), },
269 => match &state.values[0] {
&Token::Ident(ref string) => Token::PathGenericArgsWithoutColons(PathWKind::Ident(string.clone())),
_ => panic!(""), },
270 => match (&state.values[0],&state.values[1]) {
(&Token::Ident(ref string),&Token::GenericArgs(ref gens)) => Token::PathGenericArgsWithoutColons(PathWKind::IdentGeneric(string.clone(),gens.clone())),
_ => panic!(""), },
271 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Ident(ref string),&Token::LPar,&Token::MaybeTySums(ref list),&Token::RPar,&Token::RetTy(_)) => Token::PathGenericArgsWithoutColons(PathWKind::Function(string.clone(),list.clone(),Rc::new(state.values[4].clone()))),
_ => panic!(""), },
272 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PathGenericArgsWithoutColons(ref path),&Token::ModSep,&Token::Ident(ref string)) => Token::PathGenericArgsWithoutColons(PathWKind::StepIdent(Rc::new(path.clone()),string.clone())),
_ => panic!(""), },
273 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathGenericArgsWithoutColons(ref path),&Token::ModSep,&Token::Ident(ref string),&Token::GenericArgs(ref gens)) => Token::PathGenericArgsWithoutColons(PathWKind::StepIdentGeneric(Rc::new(path.clone()),string.clone(),gens.clone())),
_ => panic!(""), },
274 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::PathGenericArgsWithoutColons(ref path),&Token::ModSep,&Token::Ident(ref string),&Token::LPar,&Token::MaybeTySums(ref list),&Token::RPar,&Token::RetTy(_)) => Token::PathGenericArgsWithoutColons(PathWKind::StepFunction(Rc::new(path.clone()),string.clone(),list.clone(),Rc::new(state.values[6].clone()))),
_ => panic!(""), },
275 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::LT,&Token::MaybeSpace,&Token::GenericValues(ref list),&Token::GT,&Token::MaybeSpace) => Token::GenericArgs(list.clone()),
_ => panic!(""), },
276 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::LT,&Token::MaybeSpace,&Token::GenericValues(ref list),&Token::GE,&Token::MaybeSpace) => Token::GenericArgs(list.clone()),
_ => panic!(""), },
277 => match &state.values[0] {
&Token::MaybeTySumsAndOrBindings(ref list) => Token::GenericValues(list.clone()),
_ => panic!(""), },
278 => match &state.values[0] {
&Token::TySums(ref list) => Token::MaybeTySumsAndOrBindings(list.clone()),
_ => panic!(""), },
279 => match (&state.values[0],&state.values[1]) {
(&Token::TySums(ref list),&Token::Comma) => Token::MaybeTySumsAndOrBindings(list.clone()),
_ => panic!(""), },
280 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::TySums(ref list),&Token::Comma,&Token::Bindings) => Token::MaybeTySumsAndOrBindings(list.clone()),
_ => panic!(""), },
281 => match &state.values[0] {
&Token::Bindings => Token::MaybeTySumsAndOrBindings(vec![]),
_ => panic!(""), },
282 => match (&state.values[0],&state.values[1]) {
(&Token::Bindings,&Token::Comma) => Token::MaybeTySumsAndOrBindings(vec![]),
_ => panic!(""), },
283 => match () {
() => Token::MaybeTySumsAndOrBindings(vec![]),
_ => panic!(""), },
284 => match (&state.values[0],&state.values[1]) {
(&Token::Comma,&Token::Bindings) => Token::MaybeBindings,
_ => panic!(""), },
285 => match () {
() => Token::MaybeBindings,
_ => panic!(""), },
286 => match &state.values[0] {
&Token::Underscore => Token::Pat(PatKind::Underscore),
_ => panic!(""), },
287 => match (&state.values[0],&state.values[1]) {
(&Token::Ampersand,&Token::Pat(ref kind)) => Token::Pat(PatKind::Ref(Rc::new(kind.clone()))),
_ => panic!(""), },
288 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ampersand,&Token::Mut,&Token::Pat(ref kind)) => Token::Pat(PatKind::RefMut(Rc::new(kind.clone()))),
_ => panic!(""), },
289 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::AndAnd,&Token::Mut,&Token::Pat(ref kind)) => Token::Pat(PatKind::Ref(Rc::new(PatKind::RefMut(Rc::new(kind.clone()))))),
_ => panic!(""), },
290 => match (&state.values[0],&state.values[1]) {
(&Token::LPar,&Token::RPar) => Token::Pat(PatKind::Void),
_ => panic!(""), },
291 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::PatTup(ref patterns),&Token::RPar) => Token::Pat(PatKind::Tuple(patterns.clone())),
_ => panic!(""), },
292 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBracket,&Token::PatVec,&Token::RBracket) => Token::Pat(PatKind::Fixme),
_ => panic!(""), },
293 => match &state.values[0] {
&Token::LitOrPath(ref path) => Token::Pat(PatKind::Path(path.clone())),
_ => panic!(""), },
294 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LitOrPath(_),&Token::DotDotDot,&Token::LitOrPath(_)) => Token::Pat(PatKind::Fixme),
_ => panic!(""), },
295 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathExpr(_),&Token::LBrace,&Token::PatStruct,&Token::RBrace) => Token::Pat(PatKind::Fixme),
_ => panic!(""), },
296 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PathExpr(_),&Token::LPar,&Token::RPar) => Token::Pat(PatKind::EnumEmpty(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
297 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathExpr(_),&Token::LPar,&Token::PatTup(ref patterns),&Token::RPar) => Token::Pat(PatKind::Enum(Rc::new(state.values[0].clone()),patterns.clone())),
_ => panic!(""), },
298 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathExpr(_),&Token::Bang,&Token::MaybeIdent,&Token::DelimitedTokenTrees(_)) => Token::Pat(PatKind::Fixme),
_ => panic!(""), },
299 => match (&state.values[0],&state.values[1]) {
(&Token::BindingMode(ref bind),&Token::Ident(ref string)) => Token::Pat(PatKind::BindedIdent(bind.clone(),string.clone())),
_ => panic!(""), },
300 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ident(_),&Token::At,&Token::Pat(_)) => Token::Pat(PatKind::Fixme),
_ => panic!(""), },
301 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::BindingMode(_),&Token::Ident(_),&Token::At,&Token::Pat(_)) => Token::Pat(PatKind::Fixme),
_ => panic!(""), },
302 => match (&state.values[0],&state.values[1]) {
(&Token::BOX,&Token::Pat(_)) => Token::Pat(PatKind::Fixme),
_ => panic!(""), },
303 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::LT,&Token::TySum(_),&Token::MaybeAsTraitRef,&Token::GT,&Token::ModSep,&Token::Ident(_)) => Token::Pat(PatKind::Fixme),
_ => panic!(""), },
304 => match &state.values[0] {
&Token::Pat(ref kind) => Token::PatsOr(kind.clone()),
_ => panic!(""), },
305 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PatsOr(ref kind),&Token::Vertical,&Token::Pat(_)) => Token::PatsOr(kind.clone()),//FIXME
_ => panic!(""), },
306 => match &state.values[0] {
&Token::Ref => Token::BindingMode(BindKind::Ref),
_ => panic!(""), },
307 => match (&state.values[0],&state.values[1]) {
(&Token::Ref,&Token::Mut) => Token::BindingMode(BindKind::RefMut),
_ => panic!(""), },
308 => match &state.values[0] {
&Token::Mut => Token::BindingMode(BindKind::Mut),
_ => panic!(""), },
309 => match &state.values[0] {
&Token::PathExpr(ref path) => Token::LitOrPath(path.clone()),
_ => panic!(""), },
310 => match &state.values[0] {
&Token::Lit(ref token) => Token::LitOrPath(PathKind::Literal(token.clone())),
_ => panic!(""), },
311 => match (&state.values[0],&state.values[1]) {
(&Token::Minus,&Token::Lit(_)) => Token::LitOrPath(PathKind::Fixme),
_ => panic!(""), },
312 => match &state.values[0] {
&Token::Ident(_) => Token::PatField,
_ => panic!(""), },
313 => match (&state.values[0],&state.values[1]) {
(&Token::BindingMode(_),&Token::Ident(_)) => Token::PatField,
_ => panic!(""), },
314 => match (&state.values[0],&state.values[1]) {
(&Token::BOX,&Token::Ident(_)) => Token::PatField,
_ => panic!(""), },
315 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::BOX,&Token::BindingMode(_),&Token::Ident(_)) => Token::PatField,
_ => panic!(""), },
316 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ident(_),&Token::Colon,&Token::Pat(_)) => Token::PatField,
_ => panic!(""), },
317 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::BindingMode(_),&Token::Ident(_),&Token::Colon,&Token::Pat(_)) => Token::PatField,
_ => panic!(""), },
318 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LitInteger(_),&Token::Colon,&Token::Pat(_)) => Token::PatField,
_ => panic!(""), },
319 => match &state.values[0] {
&Token::PatField => Token::PatFields,
_ => panic!(""), },
320 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PatFields,&Token::Comma,&Token::PatField) => Token::PatFields,
_ => panic!(""), },
321 => match &state.values[0] {
&Token::PatFields => Token::PatStruct,
_ => panic!(""), },
322 => match (&state.values[0],&state.values[1]) {
(&Token::PatFields,&Token::Comma) => Token::PatStruct,
_ => panic!(""), },
323 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PatFields,&Token::Comma,&Token::DotDot) => Token::PatStruct,
_ => panic!(""), },
324 => match &state.values[0] {
&Token::DotDot => Token::PatStruct,
_ => panic!(""), },
325 => match () {
() => Token::PatStruct,
_ => panic!(""), },
326 => match &state.values[0] {
&Token::PatTupElts(ref elements) => Token::PatTup(elements.clone()),
_ => panic!(""), },
327 => match (&state.values[0],&state.values[1]) {
(&Token::PatTupElts(ref elements),&Token::Comma) => Token::PatTup(elements.clone()),
_ => panic!(""), },
328 => match (&state.values[0],&state.values[1]) {
(&Token::PatTupElts(ref elements),&Token::DotDot) => Token::PatTup(vec![]),//FIXME
_ => panic!(""), },
329 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PatTupElts(ref elements),&Token::Comma,&Token::DotDot) => Token::PatTup(vec![]),//FIXME
_ => panic!(""), },
330 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PatTupElts(ref elements),&Token::DotDot,&Token::Comma,&Token::PatTupElts(_)) => Token::PatTup(vec![]),//FIXME
_ => panic!(""), },
331 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::PatTupElts(ref elements),&Token::DotDot,&Token::Comma,&Token::PatTupElts(_),&Token::Comma) => Token::PatTup(vec![]),//FIXME
_ => panic!(""), },
332 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::PatTupElts(ref elements),&Token::Comma,&Token::DotDot,&Token::Comma,&Token::PatTupElts(_)) => Token::PatTup(vec![]),//FIXME
_ => panic!(""), },
333 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::PatTupElts(ref elements),&Token::Comma,&Token::DotDot,&Token::Comma,&Token::PatTupElts(_),&Token::Comma) => Token::PatTup(vec![]),//FIXME
_ => panic!(""), },
334 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::DotDot,&Token::Comma,&Token::PatTupElts(_)) => Token::PatTup(vec![]),//FIXME
_ => panic!(""), },
335 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::DotDot,&Token::Comma,&Token::PatTupElts(_),&Token::Comma) => Token::PatTup(vec![]),//FIXME
_ => panic!(""), },
336 => match &state.values[0] {
&Token::DotDot => Token::PatTup(vec![]),//FIXME
_ => panic!(""), },
337 => match &state.values[0] {
&Token::Pat(ref pattern) => Token::PatTupElts(vec![pattern.clone()]),
_ => panic!(""), },
338 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PatTupElts(ref elements),&Token::Comma,&Token::Pat(ref pattern)) => Token::PatTupElts({let mut new  =  elements.clone();
new.push(pattern.clone());; new}),
_ => panic!(""), },
339 => match &state.values[0] {
&Token::PatVecElts => Token::PatVec,
_ => panic!(""), },
340 => match (&state.values[0],&state.values[1]) {
(&Token::PatVecElts,&Token::Comma) => Token::PatVec,
_ => panic!(""), },
341 => match (&state.values[0],&state.values[1]) {
(&Token::PatVecElts,&Token::DotDot) => Token::PatVec,
_ => panic!(""), },
342 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PatVecElts,&Token::Comma,&Token::DotDot) => Token::PatVec,
_ => panic!(""), },
343 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PatVecElts,&Token::DotDot,&Token::Comma,&Token::PatVecElts) => Token::PatVec,
_ => panic!(""), },
344 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::PatVecElts,&Token::DotDot,&Token::Comma,&Token::PatVecElts,&Token::Comma) => Token::PatVec,
_ => panic!(""), },
345 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::PatVecElts,&Token::Comma,&Token::DotDot,&Token::Comma,&Token::PatVecElts) => Token::PatVec,
_ => panic!(""), },
346 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::PatVecElts,&Token::Comma,&Token::DotDot,&Token::Comma,&Token::PatVecElts,&Token::Comma) => Token::PatVec,
_ => panic!(""), },
347 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::DotDot,&Token::Comma,&Token::PatVecElts) => Token::PatVec,
_ => panic!(""), },
348 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::DotDot,&Token::Comma,&Token::PatVecElts,&Token::Comma) => Token::PatVec,
_ => panic!(""), },
349 => match &state.values[0] {
&Token::DotDot => Token::PatVec,
_ => panic!(""), },
350 => match () {
() => Token::PatVec,
_ => panic!(""), },
351 => match &state.values[0] {
&Token::Pat(_) => Token::PatVecElts,
_ => panic!(""), },
352 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PatVecElts,&Token::Comma,&Token::Pat(_)) => Token::PatVecElts,
_ => panic!(""), },
353 => match &state.values[0] {
&Token::TyPrim(ref kind) => Token::Ty(kind.clone()),
_ => panic!(""), },
354 => match &state.values[0] {
&Token::TyClosure => Token::Ty(TyKind::Fixme),
_ => panic!(""), },
355 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::LT,&Token::TySum(_),&Token::MaybeAsTraitRef,&Token::GT,&Token::ModSep,&Token::Ident(_)) => Token::Ty(TyKind::Fixme),
_ => panic!(""), },
356 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::TySums(ref list),&Token::RPar) => Token::Ty(TyKind::Tuple(list.clone())),
_ => panic!(""), },
357 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LPar,&Token::TySums(ref list),&Token::Comma,&Token::RPar) => Token::Ty(TyKind::Tuple(list.clone())),
_ => panic!(""), },
358 => match (&state.values[0],&state.values[1]) {
(&Token::LPar,&Token::RPar) => Token::Ty(TyKind::Void),
_ => panic!(""), },
359 => match &state.values[0] {
&Token::PathGenericArgsWithoutColons(ref path) => Token::TyPrim(TyKind::Path(path.clone())),
_ => panic!(""), },
360 => match (&state.values[0],&state.values[1]) {
(&Token::ModSep,&Token::PathGenericArgsWithoutColons(_)) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
361 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LittleSelf,&Token::ModSep,&Token::PathGenericArgsWithoutColons(_)) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
362 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathGenericArgsWithoutColons(_),&Token::Bang,&Token::MaybeIdent,&Token::DelimitedTokenTrees(_)) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
363 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::ModSep,&Token::PathGenericArgsWithoutColons(_),&Token::Bang,&Token::MaybeIdent,&Token::DelimitedTokenTrees(_)) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
364 => match (&state.values[0],&state.values[1]) {
(&Token::BOX,&Token::Ty(_)) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
365 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Star,&Token::MaybeMutOrConst,&Token::Ty(_)) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
366 => match (&state.values[0],&state.values[1]) {
(&Token::Ampersand,&Token::Ty(ref kind)) => Token::TyPrim(TyKind::Ref(Rc::new(kind.clone()))),
_ => panic!(""), },
367 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ampersand,&Token::Mut,&Token::Ty(ref kind)) => Token::TyPrim(TyKind::RefMut(Rc::new(kind.clone()))),
_ => panic!(""), },
368 => match (&state.values[0],&state.values[1]) {
(&Token::AndAnd,&Token::Ty(_)) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
369 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::AndAnd,&Token::Mut,&Token::Ty(_)) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
370 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Ampersand,&Token::Lifetime(ref lifetime),&Token::MaybeMut(ismut),&Token::Ty(ref t)) => Token::TyPrim(TyKind::RefLifetime(lifetime.clone(),ismut,Rc::new(t.clone()))),
_ => panic!(""), },
371 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBracket,&Token::Ty(_),&Token::RBracket) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
372 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::LBracket,&Token::Ty(_),&Token::Comma,&Token::DotDot,&Token::Expr(_),&Token::RBracket) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
373 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::LBracket,&Token::Ty(_),&Token::Semicolon,&Token::Expr(_),&Token::RBracket) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
374 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Typeof,&Token::LPar,&Token::Expr(_),&Token::RPar) => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
375 => match &state.values[0] {
&Token::Underscore => Token::TyPrim(TyKind::Underscore),
_ => panic!(""), },
376 => match &state.values[0] {
&Token::TyBareFn => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
377 => match &state.values[0] {
&Token::ForInType => Token::TyPrim(TyKind::Fixme),
_ => panic!(""), },
378 => match (&state.values[0],&state.values[1]) {
(&Token::FN,&Token::TyFnDecl) => Token::TyBareFn,
_ => panic!(""), },
379 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Unsafe,&Token::FN,&Token::TyFnDecl) => Token::TyBareFn,
_ => panic!(""), },
380 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Extern,&Token::FN,&Token::TyFnDecl) => Token::TyBareFn,
_ => panic!(""), },
381 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Unsafe,&Token::Extern,&Token::FN,&Token::TyFnDecl) => Token::TyBareFn,
_ => panic!(""), },
382 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::GenericParams(_,_),&Token::FnAnonParams,&Token::RetTy(_)) => Token::TyFnDecl,
_ => panic!(""), },
383 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::Unsafe,&Token::Vertical,&Token::AnonParams,&Token::Vertical,&Token::MaybeBounds,&Token::RetTy(_)) => Token::TyClosure,
_ => panic!(""), },
384 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Vertical,&Token::AnonParams,&Token::Vertical,&Token::MaybeBounds,&Token::RetTy(_)) => Token::TyClosure,
_ => panic!(""), },
385 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Unsafe,&Token::OrOr,&Token::MaybeBounds,&Token::RetTy(_)) => Token::TyClosure,
_ => panic!(""), },
386 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::OrOr,&Token::MaybeBounds,&Token::RetTy(_)) => Token::TyClosure,
_ => panic!(""), },
387 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::For,&Token::LT,&Token::MaybeLifetimes,&Token::GT,&Token::ForInTypeSuffix) => Token::ForInType,
_ => panic!(""), },
388 => match &state.values[0] {
&Token::TyBareFn => Token::ForInTypeSuffix,
_ => panic!(""), },
389 => match &state.values[0] {
&Token::TraitRef(_) => Token::ForInTypeSuffix,
_ => panic!(""), },
390 => match &state.values[0] {
&Token::TyClosure => Token::ForInTypeSuffix,
_ => panic!(""), },
391 => match &state.values[0] {
&Token::Mut => Token::MaybeMut(true),
_ => panic!(""), },
392 => match () {
() => Token::MaybeMut(false),
_ => panic!(""), },
393 => match &state.values[0] {
&Token::Mut => Token::MaybeMutOrConst,
_ => panic!(""), },
394 => match &state.values[0] {
&Token::Const => Token::MaybeMutOrConst,
_ => panic!(""), },
395 => match () {
() => Token::MaybeMutOrConst,
_ => panic!(""), },
396 => match (&state.values[0],&state.values[1]) {
(&Token::TyQualifiedPath,&Token::MaybeBindings) => Token::TyQualifiedPathAndGenericValues,
_ => panic!(""), },
397 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::TyQualifiedPath,&Token::Comma,&Token::TySums(_),&Token::MaybeBindings) => Token::TyQualifiedPathAndGenericValues,
_ => panic!(""), },
398 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::TySums(_),&Token::As,&Token::TraitRef(_),&Token::GT,&Token::ModSep,&Token::Ident(_)) => Token::TyQualifiedPath,
_ => panic!(""), },
399 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::TySums(_),&Token::As,&Token::TraitRef(_),&Token::GT,&Token::ModSep,&Token::Ident(_),&Token::Plus,&Token::TyParamBounds) => Token::TyQualifiedPath,
_ => panic!(""), },
400 => match &state.values[0] {
&Token::TySums(ref types) => Token::MaybeTySums(types.clone()),
_ => panic!(""), },
401 => match (&state.values[0],&state.values[1]) {
(&Token::TySums(ref types),&Token::Comma) => Token::MaybeTySums(types.clone()),
_ => panic!(""), },
402 => match () {
() => Token::MaybeTySums(vec![]),
_ => panic!(""), },
403 => match &state.values[0] {
&Token::TySum(ref t) => Token::TySums(vec![t.clone()]),
_ => panic!(""), },
404 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::TySums(ref types),&Token::Comma,&Token::TySum(ref t)) => Token::TySums({let mut new  =  types.clone();
new.push(t.clone());; new}),
_ => panic!(""), },
405 => match &state.values[0] {
&Token::TySumElt(ref kind) => Token::TySum(kind.clone()),
_ => panic!(""), },
406 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::TySum(ref kind),&Token::Plus,&Token::TySumElt(_)) => Token::TySum(kind.clone()),
_ => panic!(""), },
407 => match &state.values[0] {
&Token::Ty(ref kind) => Token::TySumElt(TyLf::Type(kind.clone())),
_ => panic!(""), },
408 => match &state.values[0] {
&Token::Lifetime(ref string) => Token::TySumElt(TyLf::Lifetime(string.clone())),
_ => panic!(""), },
409 => match &state.values[0] {
&Token::TyPrimSumElt(ref t) => Token::TyPrimSum(t.clone()),
_ => panic!(""), },
410 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::TyPrimSum(ref t),&Token::Plus,&Token::TyPrimSumElt(_)) => Token::TyPrimSum(t.clone()),
_ => panic!(""), },
411 => match &state.values[0] {
&Token::TyPrim(ref t) => Token::TyPrimSumElt(TyLf::Type(t.clone())),
_ => panic!(""), },
412 => match &state.values[0] {
&Token::Lifetime(ref lifetime) => Token::TyPrimSumElt(TyLf::Lifetime(lifetime.clone())),
_ => panic!(""), },
413 => match (&state.values[0],&state.values[1]) {
(&Token::Colon,&Token::TyParamBounds) => Token::MaybeTyParamBounds,
_ => panic!(""), },
414 => match () {
() => Token::MaybeTyParamBounds,
_ => panic!(""), },
415 => match &state.values[0] {
&Token::Boundseq => Token::TyParamBounds,
_ => panic!(""), },
416 => match () {
() => Token::TyParamBounds,
_ => panic!(""), },
417 => match &state.values[0] {
&Token::Polybound => Token::Boundseq,
_ => panic!(""), },
418 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Boundseq,&Token::Plus,&Token::Polybound) => Token::Boundseq,
_ => panic!(""), },
419 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::For,&Token::LT,&Token::MaybeLifetimes,&Token::GT,&Token::Bound) => Token::Polybound,
_ => panic!(""), },
420 => match &state.values[0] {
&Token::Bound => Token::Polybound,
_ => panic!(""), },
421 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::QuestionMark,&Token::For,&Token::LT,&Token::MaybeLifetimes,&Token::GT,&Token::Bound) => Token::Polybound,
_ => panic!(""), },
422 => match (&state.values[0],&state.values[1]) {
(&Token::QuestionMark,&Token::Bound) => Token::Polybound,
_ => panic!(""), },
423 => match &state.values[0] {
&Token::Binding => Token::Bindings,
_ => panic!(""), },
424 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Bindings,&Token::Comma,&Token::Binding) => Token::Bindings,
_ => panic!(""), },
425 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ident(_),&Token::Equal,&Token::Ty(_)) => Token::Binding,
_ => panic!(""), },
426 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ident(ref s),&Token::MaybeTyParamBounds,&Token::MaybeTyDefault) => Token::TyParam(s.clone()),
_ => panic!(""), },
427 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Ident(ref s),&Token::QuestionMark,&Token::Ident(_),&Token::MaybeTyParamBounds,&Token::MaybeTyDefault) => Token::TyParam(s.clone()),
_ => panic!(""), },
428 => match (&state.values[0],&state.values[1]) {
(&Token::Colon,&Token::Bounds) => Token::MaybeBounds,
_ => panic!(""), },
429 => match () {
() => Token::MaybeBounds,
_ => panic!(""), },
430 => match &state.values[0] {
&Token::Bounds => Token::Bounds,
_ => panic!(""), },
431 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Bounds,&Token::Plus,&Token::Bound) => Token::Bounds,
_ => panic!(""), },
432 => match &state.values[0] {
&Token::Lifetime(_) => Token::Bound,
_ => panic!(""), },
433 => match &state.values[0] {
&Token::TraitRef(_) => Token::Bound,
_ => panic!(""), },
434 => match (&state.values[0],&state.values[1]) {
(&Token::Colon,&Token::LTBounds) => Token::MaybeLTBounds,
_ => panic!(""), },
435 => match () {
() => Token::MaybeLTBounds,
_ => panic!(""), },
436 => match &state.values[0] {
&Token::Lifetime(_) => Token::LTBounds,
_ => panic!(""), },
437 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LTBounds,&Token::Plus,&Token::Lifetime(_)) => Token::LTBounds,
_ => panic!(""), },
438 => match (&state.values[0],&state.values[1]) {
(&Token::Equal,&Token::TySum(_)) => Token::MaybeTyDefault,
_ => panic!(""), },
439 => match () {
() => Token::MaybeTyDefault,
_ => panic!(""), },
440 => match &state.values[0] {
&Token::Lifetimes(_) => Token::MaybeLifetimes,
_ => panic!(""), },
441 => match (&state.values[0],&state.values[1]) {
(&Token::Lifetimes(_),&Token::Comma) => Token::MaybeLifetimes,
_ => panic!(""), },
442 => match () {
() => Token::MaybeLifetimes,
_ => panic!(""), },
443 => match &state.values[0] {
&Token::LifetimeAndBounds(ref string) => Token::Lifetimes(vec![string.clone()]),
_ => panic!(""), },
444 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Lifetimes(ref list),&Token::Comma,&Token::LifetimeAndBounds(ref lifetime)) =>
{
	let mut new=list.clone();
	new.push(lifetime.clone());
	Token::Lifetimes(new)
},
_ => panic!(""), },
445 => match (&state.values[0],&state.values[1]) {
(&Token::LiteralLifetime(ref string),&Token::MaybeLTBounds) => Token::LifetimeAndBounds(string.clone()),
_ => panic!(""), },
446 => match &state.values[0] {
&Token::StaticLifetime => Token::LifetimeAndBounds(String::from("'static")),
_ => panic!(""), },
447 => match &state.values[0] {
&Token::LiteralLifetime(ref string) => Token::Lifetime(string.clone()),
_ => panic!(""), },
448 => match &state.values[0] {
&Token::StaticLifetime => Token::Lifetime(String::from("'static")),
_ => panic!(""), },
449 => match &state.values[0] {
&Token::PathGenericArgsWithoutColons(ref path) => Token::TraitRef(path.clone()),
_ => panic!(""), },
450 => match (&state.values[0],&state.values[1]) {
(&Token::ModSep,&Token::PathGenericArgsWithoutColons(ref path)) => Token::TraitRef(path.clone()),
_ => panic!(""), },
451 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::LBrace,&Token::MaybeInnerAttrs,&Token::MaybeStmts(ref stmts,ref oe),&Token::RBrace) => Token::InnerAttrsAndBlock(stmts.clone(),oe.clone()),
_ => panic!(""), },
452 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBrace,&Token::MaybeStmts(ref list,ref option),&Token::RBrace) => Token::Block(list.clone(),option.clone()),
_ => panic!(""), },
453 => match &state.values[0] {
&Token::Stmts(ref list) => Token::MaybeStmts(list.clone(),None),
_ => panic!(""), },
454 => match (&state.values[0],&state.values[1]) {
(&Token::Stmts(ref list),&Token::NonblockExpr(ref expr)) => Token::MaybeStmts(list.clone(),Some(expr.clone())),
_ => panic!(""), },
455 => match &state.values[0] {
&Token::NonblockExpr(ref expr) => Token::MaybeStmts(vec![],Some(expr.clone())),
_ => panic!(""), },
456 => match () {
() => Token::MaybeStmts(vec![],None),
_ => panic!(""), },
457 => match &state.values[0] {
&Token::Stmt(ref stmt) => Token::Stmts(vec![stmt.clone()]),
_ => panic!(""), },
458 => match (&state.values[0],&state.values[1]) {
(&Token::Stmts(ref stmts),&Token::Stmt(ref stmt)) => Token::Stmts({let mut new  =  stmts.clone();
new.push(stmt.clone());; new}),
_ => panic!(""), },
459 => match (&state.values[0],&state.values[1]) {
(&Token::MaybeOuterAttrs(_),&Token::Let(ref stmt)) => Token::Stmt(stmt.clone()),
_ => panic!(""), },
460 => match &state.values[0] {
&Token::StmtItem(ref item) => Token::Stmt(StmtKind::Item(vec![],item.clone())),
_ => panic!(""), },
461 => match (&state.values[0],&state.values[1]) {
(&Token::Pub,&Token::StmtItem(ref item)) => Token::Stmt(StmtKind::Item(vec![],item.clone())),
_ => panic!(""), },
462 => match (&state.values[0],&state.values[1]) {
(&Token::OuterAttrs(ref attrs),&Token::StmtItem(ref item)) => Token::Stmt(StmtKind::Item(attrs.clone(),item.clone())),
_ => panic!(""), },
463 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::OuterAttrs(ref attrs),&Token::Pub,&Token::StmtItem(ref item)) => Token::Stmt(StmtKind::Item(attrs.clone(),item.clone())),
_ => panic!(""), },
464 => match &state.values[0] {
&Token::FullBlockExpr(ref block) => Token::Stmt(StmtKind::Block(vec![],block.clone())),
_ => panic!(""), },
465 => match (&state.values[0],&state.values[1]) {
(&Token::MaybeOuterAttrs(ref attrs),&Token::Block(_,_)) => Token::Stmt(StmtKind::Block(attrs.clone(),Rc::new(state.values[1].clone()))),
_ => panic!(""), },
466 => match (&state.values[0],&state.values[1]) {
(&Token::NonblockExpr(ref expr),&Token::Semicolon) => Token::Stmt(StmtKind::Expr(vec![],expr.clone())),
_ => panic!(""), },
467 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::OuterAttrs(ref attrs),&Token::NonblockExpr(ref expr),&Token::Semicolon) => Token::Stmt(StmtKind::Expr(attrs.clone(),expr.clone())),
_ => panic!(""), },
468 => match &state.values[0] {
&Token::Semicolon => Token::Stmt(StmtKind::Empty),
_ => panic!(""), },
469 => match &state.values[0] {
&Token::Exprs(ref list) => Token::MaybeExprs(list.clone()),
_ => panic!(""), },
470 => match (&state.values[0],&state.values[1]) {
(&Token::Exprs(ref list),&Token::Comma) => Token::MaybeExprs(list.clone()),
_ => panic!(""), },
471 => match () {
() => Token::MaybeExprs(vec![]),
_ => panic!(""), },
472 => match &state.values[0] {
&Token::Expr(ref expr) => Token::MaybeExpr(Some(expr.clone())),
_ => panic!(""), },
473 => match () {
() => Token::MaybeExpr(None),
_ => panic!(""), },
474 => match &state.values[0] {
&Token::Expr(ref expr) => Token::Exprs(vec![expr.clone()]),
_ => panic!(""), },
475 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Exprs(ref list),&Token::Comma,&Token::Expr(ref expr)) => Token::Exprs({let mut new  =  list.clone();
new.push(expr.clone());; new}),
_ => panic!(""), },
476 => match &state.values[0] {
&Token::PathGenericArgsWithColons(ref s) => Token::PathExpr(s.clone()),
_ => panic!(""), },
477 => match (&state.values[0],&state.values[1]) {
(&Token::ModSep,&Token::PathGenericArgsWithColons(ref path)) => Token::PathExpr(PathKind::Absolute(Rc::new(path.clone()))),
_ => panic!(""), },
478 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LittleSelf,&Token::ModSep,&Token::PathGenericArgsWithColons(ref path)) => Token::PathExpr(PathKind::FromSelf(Rc::new(path.clone()))),
_ => panic!(""), },
479 => match &state.values[0] {
&Token::Ident(ref s) => Token::PathGenericArgsWithColons(PathKind::Ident(s.clone())),
_ => panic!(""), },
480 => match &state.values[0] {
&Token::Super => Token::PathGenericArgsWithColons(PathKind::Super),
_ => panic!(""), },
481 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PathGenericArgsWithColons(ref path),&Token::ModSep,&Token::Ident(ref s)) => Token::PathGenericArgsWithColons(PathKind::StepIdent(Rc::new(path.clone()),s.clone())),
_ => panic!(""), },
482 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PathGenericArgsWithColons(ref path),&Token::ModSep,&Token::Super) => Token::PathGenericArgsWithColons(PathKind::StepSuper(Rc::new(path.clone()))),
_ => panic!(""), },
483 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::PathGenericArgsWithColons(ref path),&Token::ModSep,&Token::GenericArgs(ref ga)) => Token::PathGenericArgsWithColons(PathKind::GenericArgs(Rc::new(path.clone()),ga.clone())),
_ => panic!(""), },
484 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathExpr(ref s),&Token::Bang,&Token::MaybeIdent,&Token::ParensDelimitedTokenTrees(ref trees)) => Token::MacroExpr(Rc::new(Token::PathExpr(s.clone())),None,Rc::new(Token::ParensDelimitedTokenTrees(trees.clone()))),
_ => panic!(""), },
485 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathExpr(ref s),&Token::Bang,&Token::MaybeIdent,&Token::BracketsDelimitedTokenTrees(ref trees)) => Token::MacroExpr(Rc::new(Token::PathExpr(s.clone())),None,Rc::new(Token::BracketsDelimitedTokenTrees(trees.clone()))),
_ => panic!(""), },
486 => match &state.values[0] {
&Token::Lit(_) => Token::NonblockExpr(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
487 => match &state.values[0] {
&Token::PathExpr(_) => Token::NonblockExpr(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
488 => match &state.values[0] {
&Token::LittleSelf => Token::NonblockExpr(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
489 => match &state.values[0] {
&Token::MacroExpr(_,_,_) => Token::NonblockExpr(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
490 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathExpr(ref path),&Token::LBrace,&Token::StructExprFields(ref fields),&Token::RBrace) => Token::NonblockExpr(ExprKind::Struct(path.clone(),fields.clone())),
_ => panic!(""), },
491 => match (&state.values[0],&state.values[1]) {
(&Token::NonblockExpr(_),&Token::QuestionMark) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
492 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref kind),&Token::Dot,&Token::PathGenericArgsWithColons(ref path)) => Token::NonblockExpr(ExprKind::Member(Rc::new(kind.clone()),path.clone())),
_ => panic!(""), },
493 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(_),&Token::Dot,&Token::LitInteger(_)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
494 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::NonblockExpr(ref kind),&Token::LBracket,&Token::MaybeExpr(ref option),&Token::RBracket) => Token::NonblockExpr(match option
	{
		&None => ExprKind::Index(Rc::new(kind.clone()),None),
		&Some(ref qindex) => ExprKind::Index(Rc::new(kind.clone()),Some(Rc::new(qindex.clone()))),
	}),
_ => panic!(""), },
495 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::NonblockExpr(ref kind),&Token::LPar,&Token::MaybeExprs(ref arguments),&Token::RPar) => Token::NonblockExpr(ExprKind::Call(Rc::new(kind.clone()),arguments.clone())),
_ => panic!(""), },
496 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBracket,&Token::VecExpr,&Token::RBracket) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
497 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::MaybeExprs(ref arguments),&Token::RPar) => Token::NonblockExpr(ExprKind::Parentheses(arguments.clone())),
_ => panic!(""), },
498 => match &state.values[0] {
&Token::Continue => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
499 => match (&state.values[0],&state.values[1]) {
(&Token::Continue,&Token::Lifetime(_)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
500 => match &state.values[0] {
&Token::Return => Token::NonblockExpr(ExprKind::Return(None)),
_ => panic!(""), },
501 => match (&state.values[0],&state.values[1]) {
(&Token::Return,&Token::Expr(ref expr)) => Token::NonblockExpr(ExprKind::Return(Some(Rc::new(expr.clone())))),
_ => panic!(""), },
502 => match &state.values[0] {
&Token::Break => Token::NonblockExpr(ExprKind::Break(None)),
_ => panic!(""), },
503 => match (&state.values[0],&state.values[1]) {
(&Token::Break,&Token::Lifetime(ref lifetime)) => Token::NonblockExpr(ExprKind::Break(Some(lifetime.clone()))),
_ => panic!(""), },
504 => match &state.values[0] {
&Token::Yield => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
505 => match (&state.values[0],&state.values[1]) {
(&Token::Yield,&Token::Expr(_)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
506 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(_),&Token::LArrow,&Token::Expr(_)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
507 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::Equal,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
508 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::NonblockExpr(ref left),&Token::LT,&Token::NoSpace,&Token::LT,&Token::Equal,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
509 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::NonblockExpr(ref left),&Token::GT,&Token::NoSpace,&Token::GT,&Token::Equal,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
510 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::MinusEqual,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
511 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::AndEqual,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
512 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::OrEqual,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
513 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::PlusEqual,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
514 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::StarEqual,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
515 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::SlashEqual,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
516 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::CaretEqual,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
517 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::PercentEqual,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
518 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::OrOr,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
519 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::AndAnd,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
520 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::EqualEqual,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
521 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::NE,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
522 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::LT,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
523 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::GT,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
524 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::LE,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
525 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::GE,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
526 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::Vertical,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
527 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::Caret,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
528 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::Ampersand,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
529 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::NonblockExpr(ref left),&Token::LT,&Token::NoSpace,&Token::LT,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
530 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::NonblockExpr(ref left),&Token::GT,&Token::NoSpace,&Token::GT,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
531 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::Plus,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
532 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::Minus,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
533 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::Star,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
534 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::Slash,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
535 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::Percent,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
536 => match (&state.values[0],&state.values[1]) {
(&Token::NonblockExpr(ref left),&Token::DotDot) => Token::NonblockExpr(ExprKind::Range(Some(Rc::new(left.clone())),None)),
_ => panic!(""), },
537 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(ref left),&Token::DotDot,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Range(Some(Rc::new(left.clone())),Some(Rc::new(right.clone())))),
_ => panic!(""), },
538 => match (&state.values[0],&state.values[1]) {
(&Token::DotDot,&Token::Expr(ref right)) => Token::NonblockExpr(ExprKind::Range(None,Some(Rc::new(right.clone())))),
_ => panic!(""), },
539 => match &state.values[0] {
&Token::DotDot => Token::NonblockExpr(ExprKind::Range(None,None)),
_ => panic!(""), },
540 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(_),&Token::As,&Token::Ty(_)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
541 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::NonblockExpr(_),&Token::Colon,&Token::Ty(_)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
542 => match (&state.values[0],&state.values[1]) {
(&Token::BOX,&Token::Expr(_)) => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
543 => match &state.values[0] {
&Token::ExprQualifiedPath => Token::NonblockExpr(ExprKind::Fixme),
_ => panic!(""), },
544 => match &state.values[0] {
&Token::NonblockPrefixExpr(ref expr) => Token::NonblockExpr(expr.clone()),
_ => panic!(""), },
545 => match &state.values[0] {
&Token::Lit(_) => Token::Expr(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
546 => match &state.values[0] {
&Token::PathExpr(_) => Token::Expr(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
547 => match &state.values[0] {
&Token::LittleSelf => Token::Expr(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
548 => match &state.values[0] {
&Token::MacroExpr(_,_,_) => Token::Expr(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
549 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathExpr(ref path),&Token::LBrace,&Token::StructExprFields(ref fields),&Token::RBrace) => Token::Expr(ExprKind::Struct(path.clone(),fields.clone())),
_ => panic!(""), },
550 => match (&state.values[0],&state.values[1]) {
(&Token::Expr(_),&Token::QuestionMark) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
551 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref kind),&Token::Dot,&Token::PathGenericArgsWithColons(ref string)) => Token::Expr(ExprKind::Member(Rc::new(kind.clone()),string.clone())),
_ => panic!(""), },
552 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(_),&Token::Dot,&Token::LitInteger(_)) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
553 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Expr(ref kind),&Token::LBracket,&Token::MaybeExpr(ref option),&Token::RBracket) => Token::Expr(match option
	{
		&None => ExprKind::Index(Rc::new(kind.clone()),None),
		&Some(ref qindex) => ExprKind::Index(Rc::new(kind.clone()),Some(Rc::new(qindex.clone()))),
	}),
_ => panic!(""), },
554 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Expr(ref kind),&Token::LPar,&Token::MaybeExprs(ref arguments),&Token::RPar) => Token::Expr(ExprKind::Call(Rc::new(kind.clone()),arguments.clone())),
_ => panic!(""), },
555 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::MaybeExprs(ref arguments),&Token::RPar) => Token::Expr(ExprKind::Parentheses(arguments.clone())),
_ => panic!(""), },
556 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBracket,&Token::VecExpr,&Token::RBracket) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
557 => match &state.values[0] {
&Token::Continue => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
558 => match (&state.values[0],&state.values[1]) {
(&Token::Continue,&Token::Ident(_)) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
559 => match &state.values[0] {
&Token::Return => Token::Expr(ExprKind::Return(None)),
_ => panic!(""), },
560 => match (&state.values[0],&state.values[1]) {
(&Token::Return,&Token::Expr(ref expr)) => Token::Expr(ExprKind::Return(Some(Rc::new(expr.clone())))),
_ => panic!(""), },
561 => match &state.values[0] {
&Token::Break => Token::Expr(ExprKind::Break(None)),
_ => panic!(""), },
562 => match (&state.values[0],&state.values[1]) {
(&Token::Break,&Token::Ident(ref string)) => Token::Expr(ExprKind::Break(Some(string.clone()))),
_ => panic!(""), },
563 => match &state.values[0] {
&Token::Yield => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
564 => match (&state.values[0],&state.values[1]) {
(&Token::Yield,&Token::Expr(_)) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
565 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(_),&Token::LArrow,&Token::Expr(_)) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
566 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::Equal,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
567 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::Expr(ref left),&Token::LT,&Token::NoSpace,&Token::LT,&Token::Equal,&Token::Expr(ref right)) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
568 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::Expr(ref left),&Token::GT,&Token::NoSpace,&Token::GT,&Token::Equal,&Token::Expr(ref right)) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
569 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::MinusEqual,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
570 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::AndEqual,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
571 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::OrEqual,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
572 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::PlusEqual,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
573 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::StarEqual,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
574 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::SlashEqual,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
575 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::CaretEqual,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
576 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::PercentEqual,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
577 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::OrOr,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
578 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::AndAnd,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
579 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::EqualEqual,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
580 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::NE,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
581 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::LT,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
582 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::GT,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
583 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::LE,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
584 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::GE,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
585 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::Vertical,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
586 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::Caret,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
587 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::Ampersand,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
588 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Expr(ref left),&Token::LT,&Token::NoSpace,&Token::LT,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
589 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Expr(ref left),&Token::GT,&Token::NoSpace,&Token::GT,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
590 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::Plus,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
591 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::Minus,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
592 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::Star,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
593 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::Slash,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
594 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::Percent,&Token::Expr(ref right)) => Token::Expr(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
595 => match (&state.values[0],&state.values[1]) {
(&Token::Expr(ref left),&Token::DotDot) => Token::Expr(ExprKind::Range(Some(Rc::new(left.clone())),None)),
_ => panic!(""), },
596 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(ref left),&Token::DotDot,&Token::Expr(ref right)) => Token::Expr(ExprKind::Range(Some(Rc::new(left.clone())),Some(Rc::new(right.clone())))),
_ => panic!(""), },
597 => match (&state.values[0],&state.values[1]) {
(&Token::DotDot,&Token::Expr(ref right)) => Token::Expr(ExprKind::Range(None,Some(Rc::new(right.clone())))),
_ => panic!(""), },
598 => match &state.values[0] {
&Token::DotDot => Token::Expr(ExprKind::Range(None,None)),
_ => panic!(""), },
599 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(_),&Token::As,&Token::Ty(_)) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
600 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Expr(_),&Token::Colon,&Token::Ty(_)) => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
601 => match (&state.values[0],&state.values[1]) {
(&Token::BOX,&Token::Expr(ref expr)) => Token::Expr(expr.clone()),//FIXME
_ => panic!(""), },
602 => match &state.values[0] {
&Token::ExprQualifiedPath => Token::Expr(ExprKind::Fixme),
_ => panic!(""), },
603 => match &state.values[0] {
&Token::BlockExpr(ref block) => Token::Expr(ExprKind::Single(block.clone())),
_ => panic!(""), },
604 => match &state.values[0] {
&Token::Block(_,_) => Token::Expr(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
605 => match &state.values[0] {
&Token::NonblockPrefixExpr(ref expr) => Token::Expr(expr.clone()),
_ => panic!(""), },
606 => match &state.values[0] {
&Token::Lit(_) => Token::ExprNostruct(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
607 => match &state.values[0] {
&Token::PathExpr(_) => Token::ExprNostruct(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
608 => match &state.values[0] {
&Token::LittleSelf => Token::ExprNostruct(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
609 => match &state.values[0] {
&Token::MacroExpr(_,_,_) => Token::ExprNostruct(ExprKind::Single(Rc::new(state.values[0].clone()))),
_ => panic!(""), },
610 => match (&state.values[0],&state.values[1]) {
(&Token::ExprNostruct(_),&Token::QuestionMark) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
611 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref kind),&Token::Dot,&Token::PathGenericArgsWithColons(ref path)) => Token::ExprNostruct(ExprKind::Member(Rc::new(kind.clone()),path.clone())),
_ => panic!(""), },
612 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(_),&Token::Dot,&Token::LitInteger(_)) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
613 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::ExprNostruct(ref kind),&Token::LBracket,&Token::MaybeExpr(ref option),&Token::RBracket) => Token::ExprNostruct(match option
{
	&None => ExprKind::Index(Rc::new(kind.clone()),None),
	&Some(ref qindex) => ExprKind::Index(Rc::new(kind.clone()),Some(Rc::new(qindex.clone()))),
}),
_ => panic!(""), },
614 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::ExprNostruct(ref kind),&Token::LPar,&Token::MaybeExprs(ref arguments),&Token::RPar) => Token::ExprNostruct(ExprKind::Call(Rc::new(kind.clone()),arguments.clone())),
_ => panic!(""), },
615 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBracket,&Token::VecExpr,&Token::RBracket) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
616 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::MaybeExprs(ref arguments),&Token::RPar) => Token::ExprNostruct(ExprKind::Parentheses(arguments.clone())),
_ => panic!(""), },
617 => match &state.values[0] {
&Token::Continue => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
618 => match (&state.values[0],&state.values[1]) {
(&Token::Continue,&Token::Ident(_)) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
619 => match &state.values[0] {
&Token::Return => Token::ExprNostruct(ExprKind::Return(None)),
_ => panic!(""), },
620 => match (&state.values[0],&state.values[1]) {
(&Token::Return,&Token::Expr(ref expr)) => Token::ExprNostruct(ExprKind::Return(Some(Rc::new(expr.clone())))),
_ => panic!(""), },
621 => match &state.values[0] {
&Token::Break => Token::ExprNostruct(ExprKind::Break(None)),
_ => panic!(""), },
622 => match (&state.values[0],&state.values[1]) {
(&Token::Break,&Token::Ident(ref string)) => Token::ExprNostruct(ExprKind::Break(Some(string.clone()))),
_ => panic!(""), },
623 => match &state.values[0] {
&Token::Yield => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
624 => match (&state.values[0],&state.values[1]) {
(&Token::Yield,&Token::Expr(_)) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
625 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::LArrow,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
626 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::Equal,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
627 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::ExprNostruct(ref left),&Token::LT,&Token::NoSpace,&Token::LT,&Token::Equal,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
628 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::ExprNostruct(ref left),&Token::GT,&Token::NoSpace,&Token::GT,&Token::Equal,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
629 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::MinusEqual,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
630 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::AndEqual,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
631 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::OrEqual,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
632 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::PlusEqual,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
633 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::StarEqual,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
634 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::SlashEqual,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
635 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::CaretEqual,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
636 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::PercentEqual,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
637 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::OrOr,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
638 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::AndAnd,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
639 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::EqualEqual,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
640 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::NE,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
641 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::LT,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
642 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::GT,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
643 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::LE,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
644 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::GE,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
645 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::Vertical,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
646 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::Caret,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
647 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::Ampersand,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
648 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::ExprNostruct(ref left),&Token::LT,&Token::NoSpace,&Token::LT,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
649 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::ExprNostruct(ref left),&Token::GT,&Token::NoSpace,&Token::GT,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
650 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::Plus,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
651 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::Minus,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
652 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::Star,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
653 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::Slash,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
654 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::Percent,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Infix(Rc::new(left.clone()),Rc::new(state.values[1].clone()),Rc::new(right.clone()))),
_ => panic!(""), },
655 => match (&state.values[0],&state.values[1]) {
(&Token::ExprNostruct(ref left),&Token::DotDot) => Token::ExprNostruct(ExprKind::Range(Some(Rc::new(left.clone())),None)),
_ => panic!(""), },
656 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(ref left),&Token::DotDot,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Range(Some(Rc::new(left.clone())),Some(Rc::new(right.clone())))),
_ => panic!(""), },
657 => match (&state.values[0],&state.values[1]) {
(&Token::DotDot,&Token::ExprNostruct(ref right)) => Token::ExprNostruct(ExprKind::Range(None,Some(Rc::new(right.clone())))),
_ => panic!(""), },
658 => match &state.values[0] {
&Token::DotDot => Token::ExprNostruct(ExprKind::Range(None,None)),
_ => panic!(""), },
659 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(_),&Token::As,&Token::Ty(_)) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
660 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::ExprNostruct(_),&Token::Colon,&Token::Ty(_)) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
661 => match (&state.values[0],&state.values[1]) {
(&Token::BOX,&Token::ExprNostruct(_)) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
662 => match &state.values[0] {
&Token::ExprQualifiedPath => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
663 => match &state.values[0] {
&Token::BlockExpr(_) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
664 => match &state.values[0] {
&Token::Block(_,_) => Token::ExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
665 => match &state.values[0] {
&Token::NonblockPrefixExprNostruct(ref expr) => Token::ExprNostruct(expr.clone()),
_ => panic!(""), },
666 => match (&state.values[0],&state.values[1]) {
(&Token::Minus,&Token::ExprNostruct(ref expr)) => Token::NonblockPrefixExprNostruct(ExprKind::Prefix(Rc::new(state.values[0].clone()),Rc::new(expr.clone()))),
_ => panic!(""), },
667 => match (&state.values[0],&state.values[1]) {
(&Token::Bang,&Token::ExprNostruct(ref expr)) => Token::NonblockPrefixExprNostruct(ExprKind::Prefix(Rc::new(state.values[0].clone()),Rc::new(expr.clone()))),
_ => panic!(""), },
668 => match (&state.values[0],&state.values[1]) {
(&Token::Star,&Token::ExprNostruct(ref expr)) => Token::NonblockPrefixExprNostruct(ExprKind::Prefix(Rc::new(state.values[0].clone()),Rc::new(expr.clone()))),
_ => panic!(""), },
669 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ampersand,&Token::MaybeMut(ismut),&Token::ExprNostruct(ref expr)) => Token::NonblockPrefixExprNostruct(if ismut {ExprKind::RefMut(Rc::new(expr.clone()))} else {ExprKind::Ref(Rc::new(expr.clone()))}),
_ => panic!(""), },
670 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::AndAnd,&Token::MaybeMut(_),&Token::ExprNostruct(_)) => Token::NonblockPrefixExprNostruct(ExprKind::Fixme),
_ => panic!(""), },
671 => match &state.values[0] {
&Token::LambdaExprNostruct(ref expr) => Token::NonblockPrefixExprNostruct(expr.clone()),
_ => panic!(""), },
672 => match (&state.values[0],&state.values[1]) {
(&Token::Move,&Token::LambdaExprNostruct(ref expr)) => Token::NonblockPrefixExprNostruct(expr.clone()),
_ => panic!(""), },
673 => match (&state.values[0],&state.values[1]) {
(&Token::Minus,&Token::Expr(ref expr)) => Token::NonblockPrefixExpr(ExprKind::Prefix(Rc::new(state.values[0].clone()),Rc::new(expr.clone()))),
_ => panic!(""), },
674 => match (&state.values[0],&state.values[1]) {
(&Token::Bang,&Token::Expr(ref expr)) => Token::NonblockPrefixExpr(ExprKind::Prefix(Rc::new(state.values[0].clone()),Rc::new(expr.clone()))),
_ => panic!(""), },
675 => match (&state.values[0],&state.values[1]) {
(&Token::Star,&Token::Expr(ref expr)) => Token::NonblockPrefixExpr(ExprKind::Prefix(Rc::new(state.values[0].clone()),Rc::new(expr.clone()))),
_ => panic!(""), },
676 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ampersand,&Token::MaybeMut(ismut),&Token::Expr(ref expr)) => Token::NonblockPrefixExpr(if ismut {ExprKind::RefMut(Rc::new(expr.clone()))} else {ExprKind::Ref(Rc::new(expr.clone()))}),
_ => panic!(""), },
677 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::AndAnd,&Token::MaybeMut(_),&Token::Expr(ref expr)) => Token::NonblockPrefixExpr(ExprKind::Fixme),
_ => panic!(""), },
678 => match &state.values[0] {
&Token::LambdaExpr(ref expr) => Token::NonblockPrefixExpr(expr.clone()),
_ => panic!(""), },
679 => match (&state.values[0],&state.values[1]) {
(&Token::Move,&Token::LambdaExpr(ref expr)) => Token::NonblockPrefixExpr(expr.clone()),
_ => panic!(""), },
680 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::LT,&Token::TySum(_),&Token::MaybeAsTraitRef,&Token::GT,&Token::ModSep,&Token::Ident(_),&Token::MaybeQPathParams) => Token::ExprQualifiedPath,
_ => panic!(""), },
681 => match (&state.values[0],&state.values[1]) {
(&Token::ModSep,&Token::GenericArgs(_)) => Token::MaybeQPathParams,
_ => panic!(""), },
682 => match () {
() => Token::MaybeQPathParams,
_ => panic!(""), },
683 => match (&state.values[0],&state.values[1]) {
(&Token::As,&Token::TraitRef(_)) => Token::MaybeAsTraitRef,
_ => panic!(""), },
684 => match () {
() => Token::MaybeAsTraitRef,
_ => panic!(""), },
685 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::OrOr,&Token::RetTy(ref ot),&Token::Expr(ref expr)) => Token::LambdaExpr(ExprKind::Lambda(vec![],ot.clone(),Rc::new(expr.clone()))),
_ => panic!(""), },
686 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Vertical,&Token::Vertical,&Token::RetTy(ref ot),&Token::Expr(ref expr)) => Token::LambdaExpr(ExprKind::Lambda(vec![],ot.clone(),Rc::new(expr.clone()))),
_ => panic!(""), },
687 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Vertical,&Token::InferrableParams(ref params),&Token::Vertical,&Token::RetTy(ref ot),&Token::Expr(ref expr)) => Token::LambdaExpr(ExprKind::Lambda(params.clone(),ot.clone(),Rc::new(expr.clone()))),
_ => panic!(""), },
688 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Vertical,&Token::InferrableParams(ref params),&Token::OrOr,&Token::LambdaExprNoFirstBar(ref expr)) => Token::LambdaExpr(ExprKind::Lambda(params.clone(),None,Rc::new(expr.clone()))),
_ => panic!(""), },
689 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Vertical,&Token::RetTy(ref ot),&Token::Expr(ref expr)) => Token::LambdaExprNoFirstBar(ExprKind::Lambda(vec![],ot.clone(),Rc::new(expr.clone()))),
_ => panic!(""), },
690 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::InferrableParams(ref params),&Token::Vertical,&Token::RetTy(ref ot),&Token::Expr(ref expr)) => Token::LambdaExprNoFirstBar(ExprKind::Lambda(params.clone(),ot.clone(),Rc::new(expr.clone()))),
_ => panic!(""), },
691 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::InferrableParams(ref params),&Token::OrOr,&Token::LambdaExprNoFirstBar(ref expr)) => Token::LambdaExprNoFirstBar(ExprKind::Lambda(params.clone(),None,Rc::new(expr.clone()))),
_ => panic!(""), },
692 => match (&state.values[0],&state.values[1]) {
(&Token::OrOr,&Token::ExprNostruct(ref expr)) => Token::LambdaExprNostruct(ExprKind::Lambda(vec![],None,Rc::new(expr.clone()))),
_ => panic!(""), },
693 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Vertical,&Token::Vertical,&Token::RetTy(ref ot),&Token::ExprNostruct(ref expr)) => Token::LambdaExprNostruct(ExprKind::Lambda(vec![],ot.clone(),Rc::new(expr.clone()))),
_ => panic!(""), },
694 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Vertical,&Token::InferrableParams(ref params),&Token::Vertical,&Token::ExprNostruct(ref expr)) => Token::LambdaExprNostruct(ExprKind::Lambda(params.clone(),None,Rc::new(expr.clone()))),
_ => panic!(""), },
695 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Vertical,&Token::InferrableParams(ref params),&Token::OrOr,&Token::LambdaExprNostructNoFirstBar(ref expr)) => Token::LambdaExprNostruct(ExprKind::Lambda(params.clone(),None,Rc::new(expr.clone()))),
_ => panic!(""), },
696 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Vertical,&Token::RetTy(ref ot),&Token::ExprNostruct(ref expr)) => Token::LambdaExprNostructNoFirstBar(ExprKind::Lambda(vec![],ot.clone(),Rc::new(expr.clone()))),
_ => panic!(""), },
697 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::InferrableParams(ref params),&Token::Vertical,&Token::RetTy(ref ot),&Token::ExprNostruct(ref expr)) => Token::LambdaExprNostructNoFirstBar(ExprKind::Lambda(params.clone(),ot.clone(),Rc::new(expr.clone()))),
_ => panic!(""), },
698 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::InferrableParams(ref params),&Token::OrOr,&Token::LambdaExprNostructNoFirstBar(ref expr)) =>
	Token::LambdaExprNostructNoFirstBar(ExprKind::Lambda(params.clone(),None,Rc::new(expr.clone()))),
_ => panic!(""), },
699 => match &state.values[0] {
&Token::MaybeExprs(_) => Token::VecExpr,
_ => panic!(""), },
700 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Exprs(_),&Token::Semicolon,&Token::Expr(_)) => Token::VecExpr,
_ => panic!(""), },
701 => match &state.values[0] {
&Token::FieldInits(ref list) => Token::StructExprFields(list.clone()),
_ => panic!(""), },
702 => match (&state.values[0],&state.values[1]) {
(&Token::FieldInits(ref list),&Token::Comma) => Token::StructExprFields(list.clone()),
_ => panic!(""), },
703 => match (&state.values[0],&state.values[1]) {
(&Token::MaybeFieldInits(ref list),&Token::DefaultFieldInit) => Token::StructExprFields(list.clone()),
_ => panic!(""), },
704 => match () {
() => Token::StructExprFields(vec![]),
_ => panic!(""), },
705 => match &state.values[0] {
&Token::FieldInits(ref list) => Token::MaybeFieldInits(list.clone()),
_ => panic!(""), },
706 => match (&state.values[0],&state.values[1]) {
(&Token::FieldInits(ref list),&Token::Comma) => Token::MaybeFieldInits(list.clone()),
_ => panic!(""), },
707 => match () {
() => Token::MaybeFieldInits(vec![]),
_ => panic!(""), },
708 => match &state.values[0] {
&Token::FieldInit(ref id,ref oe) => Token::FieldInits(vec![(id.clone(),oe.clone())]),
_ => panic!(""), },
709 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::FieldInits(ref list),&Token::Comma,&Token::FieldInit(ref id,ref oe)) =>
{
	let mut new=list.clone();
	new.push((id.clone(),oe.clone()));
	Token::FieldInits(new)
},
_ => panic!(""), },
710 => match &state.values[0] {
&Token::Ident(ref id) => Token::FieldInit(id.clone(),None),
_ => panic!(""), },
711 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::Ident(ref id),&Token::Colon,&Token::Expr(ref expr)) => Token::FieldInit(id.clone(),Some(expr.clone())),
_ => panic!(""), },
712 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LitInteger(ref number),&Token::Colon,&Token::Expr(ref expr)) => Token::FieldInit(number.to_string(),Some(expr.clone())),
_ => panic!(""), },
713 => match (&state.values[0],&state.values[1]) {
(&Token::DotDot,&Token::Expr(_)) => Token::DefaultFieldInit,
_ => panic!(""), },
714 => match &state.values[0] {
&Token::ExprMatch(_,_) => Token::BlockExpr(Rc::new(state.values[0].clone())),
_ => panic!(""), },
715 => match &state.values[0] {
&Token::ExprIf(_,_,_,) => Token::BlockExpr(Rc::new(state.values[0].clone())),
_ => panic!(""), },
716 => match &state.values[0] {
&Token::ExprIfLet(_,_,_,_) => Token::BlockExpr(Rc::new(state.values[0].clone())),
_ => panic!(""), },
717 => match &state.values[0] {
&Token::ExprWhile(_,_) => Token::BlockExpr(Rc::new(state.values[0].clone())),
_ => panic!(""), },
718 => match &state.values[0] {
&Token::ExprWhileLet => Token::BlockExpr(Rc::new(state.values[0].clone())),
_ => panic!(""), },
719 => match &state.values[0] {
&Token::ExprLoop => Token::BlockExpr(Rc::new(state.values[0].clone())),
_ => panic!(""), },
720 => match &state.values[0] {
&Token::ExprFor(_,_,_) => Token::BlockExpr(Rc::new(state.values[0].clone())),
_ => panic!(""), },
721 => match (&state.values[0],&state.values[1]) {
(&Token::Unsafe,&Token::Block(_,_)) => Token::BlockExpr(Rc::new(state.values[1].clone())),
_ => panic!(""), },
722 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::PathExpr(_),&Token::Bang,&Token::MaybeIdent,&Token::BracesDelimitedTokenTrees(_)) => Token::BlockExpr(Rc::new(state.values[1].clone())),//FIXME
_ => panic!(""), },
723 => match &state.values[0] {
&Token::BlockExpr(ref block) => Token::FullBlockExpr(block.clone()),
_ => panic!(""), },
724 => match &state.values[0] {
&Token::BlockExprDot => Token::FullBlockExpr(Rc::new(state.values[0].clone())),//FIXME
_ => panic!(""), },
725 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::BlockExpr(_),&Token::Dot,&Token::PathGenericArgsWithColons(_)) => Token::BlockExprDot,
_ => panic!(""), },
726 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::BlockExprDot,&Token::Dot,&Token::PathGenericArgsWithColons(_)) => Token::BlockExprDot,
_ => panic!(""), },
727 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::BlockExpr(_),&Token::Dot,&Token::PathGenericArgsWithColons(_),&Token::LBracket,&Token::MaybeExpr(_),&Token::RBracket) => Token::BlockExprDot,
_ => panic!(""), },
728 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::BlockExprDot,&Token::Dot,&Token::PathGenericArgsWithColons(_),&Token::LBracket,&Token::MaybeExpr(_),&Token::RBracket) => Token::BlockExprDot,
_ => panic!(""), },
729 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::BlockExpr(_),&Token::Dot,&Token::PathGenericArgsWithColons(_),&Token::LPar,&Token::MaybeExprs(_),&Token::RPar) => Token::BlockExprDot,
_ => panic!(""), },
730 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::BlockExprDot,&Token::Dot,&Token::PathGenericArgsWithColons(_),&Token::LPar,&Token::MaybeExprs(_),&Token::RPar) => Token::BlockExprDot,
_ => panic!(""), },
731 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::BlockExpr(_),&Token::Dot,&Token::LitInteger(_)) => Token::BlockExprDot,
_ => panic!(""), },
732 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::BlockExprDot,&Token::Dot,&Token::LitInteger(_)) => Token::BlockExprDot,
_ => panic!(""), },
733 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::Match,&Token::ExprNostruct(ref expr),&Token::LBrace,&Token::RBrace) => Token::ExprMatch(expr.clone(),vec![]),
_ => panic!(""), },
734 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Match,&Token::ExprNostruct(ref expr),&Token::LBrace,&Token::MatchClauses(ref list),&Token::RBrace) => Token::ExprMatch(expr.clone(),list.clone()),
_ => panic!(""), },
735 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::Match,&Token::ExprNostruct(ref expr),&Token::LBrace,&Token::MatchClauses(ref list),&Token::NonblockMatchClause(_,_,_,),&Token::RBrace) =>
{
	let mut new=list.clone();
	new.push(Rc::new(state.values[4].clone()));
	Token::ExprMatch(expr.clone(),new)
},
_ => panic!(""), },
736 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Match,&Token::ExprNostruct(ref expr),&Token::LBrace,&Token::NonblockMatchClause(_,_,_),&Token::RBrace) => Token::ExprMatch(expr.clone(),vec![Rc::new(state.values[3].clone())]),
_ => panic!(""), },
737 => match &state.values[0] {
&Token::MatchClause(_,_,_) => Token::MatchClauses(vec![Rc::new(state.values[0].clone())]),
_ => panic!(""), },
738 => match (&state.values[0],&state.values[1]) {
(&Token::MatchClauses(ref clauses),&Token::MatchClause(_,_,_)) => Token::MatchClauses({let mut new  =  clauses.clone();
new.push(Rc::new(state.values[1].clone()));; new}),
_ => panic!(""), },
739 => match (&state.values[0],&state.values[1]) {
(&Token::NonblockMatchClause(ref attributes,ref pattern,ref expression),&Token::Comma) => Token::MatchClause(attributes.clone(),pattern.clone(),expression.clone()),
_ => panic!(""), },
740 => match &state.values[0] {
&Token::BlockMatchClause(ref attributes,ref pattern,ref expression) => Token::MatchClause(attributes.clone(),pattern.clone(),expression.clone()),
_ => panic!(""), },
741 => match (&state.values[0],&state.values[1]) {
(&Token::BlockMatchClause(ref attributes,ref pattern,ref expression),&Token::Comma) => Token::MatchClause(attributes.clone(),pattern.clone(),expression.clone()),
_ => panic!(""), },
742 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::MaybeOuterAttrs(ref attributes),&Token::PatsOr(ref pattern),&Token::MaybeGuard,&Token::FatArrow,&Token::NonblockExpr(_)) => Token::NonblockMatchClause(attributes.clone(),pattern.clone(),Rc::new(state.values[4].clone())),
_ => panic!(""), },
743 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::MaybeOuterAttrs(ref attributes),&Token::PatsOr(ref pattern),&Token::MaybeGuard,&Token::FatArrow,&Token::BlockExprDot) => Token::NonblockMatchClause(attributes.clone(),pattern.clone(),Rc::new(state.values[4].clone())),
_ => panic!(""), },
744 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::MaybeOuterAttrs(ref attributes),&Token::PatsOr(ref pattern),&Token::MaybeGuard,&Token::FatArrow,&Token::Block(_,_)) => Token::BlockMatchClause(attributes.clone(),pattern.clone(),Rc::new(state.values[4].clone())),
_ => panic!(""), },
745 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::MaybeOuterAttrs(ref attributes),&Token::PatsOr(ref pattern),&Token::MaybeGuard,&Token::FatArrow,&Token::BlockExpr(_)) => Token::BlockMatchClause(attributes.clone(),pattern.clone(),Rc::new(state.values[4].clone())),
_ => panic!(""), },
746 => match (&state.values[0],&state.values[1]) {
(&Token::If,&Token::ExprNostruct(_)) => Token::MaybeGuard,
_ => panic!(""), },
747 => match () {
() => Token::MaybeGuard,
_ => panic!(""), },
748 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::If,&Token::ExprNostruct(ref expr),&Token::Block(_,_)) => Token::ExprIf(expr.clone(),Rc::new(state.values[2].clone()),None),
_ => panic!(""), },
749 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::If,&Token::ExprNostruct(ref expr),&Token::Block(_,_),&Token::Else,&Token::BlockOrIf(ref token)) => Token::ExprIf(expr.clone(),Rc::new(state.values[2].clone()),Some(token.clone())),
_ => panic!(""), },
750 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::If,&Token::LiteralLet,&Token::Pat(ref pattern),&Token::Equal,&Token::ExprNostruct(ref expr),&Token::Block(_,_)) => Token::ExprIfLet(pattern.clone(),expr.clone(),Rc::new(state.values[5].clone()),None),
_ => panic!(""), },
751 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::If,&Token::LiteralLet,&Token::Pat(ref pattern),&Token::Equal,&Token::ExprNostruct(ref expr),&Token::Block(_,_),&Token::Else,&Token::BlockOrIf(ref token)) => Token::ExprIfLet(pattern.clone(),expr.clone(),Rc::new(state.values[5].clone()),Some(token.clone())),
_ => panic!(""), },
752 => match &state.values[0] {
&Token::Block(_,_) => Token::BlockOrIf(Rc::new(state.values[0].clone())),
_ => panic!(""), },
753 => match &state.values[0] {
&Token::ExprIf(_,_,_) => Token::BlockOrIf(Rc::new(state.values[0].clone())),
_ => panic!(""), },
754 => match &state.values[0] {
&Token::ExprIfLet(_,_,_,_) => Token::BlockOrIf(Rc::new(state.values[0].clone())),
_ => panic!(""), },
755 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3]) {
(&Token::MaybeLabel,&Token::While,&Token::ExprNostruct(ref expr),&Token::Block(_,_)) => Token::ExprWhile(expr.clone(),Rc::new(state.values[3].clone())),
_ => panic!(""), },
756 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6]) {
(&Token::MaybeLabel,&Token::While,&Token::LiteralLet,&Token::Pat(_),&Token::Equal,&Token::ExprNostruct(_),&Token::Block(_,_)) => Token::ExprWhileLet,
_ => panic!(""), },
757 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::MaybeLabel,&Token::Loop,&Token::Block(_,_)) => Token::ExprLoop,
_ => panic!(""), },
758 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5]) {
(&Token::MaybeLabel,&Token::For,&Token::Pat(ref pattern),&Token::In,&Token::ExprNostruct(ref expr),&Token::Block(_,_)) => Token::ExprFor(pattern.clone(),expr.clone(),Rc::new(state.values[5].clone())),
_ => panic!(""), },
759 => match (&state.values[0],&state.values[1]) {
(&Token::Lifetime(_),&Token::Colon) => Token::MaybeLabel,
_ => panic!(""), },
760 => match () {
() => Token::MaybeLabel,
_ => panic!(""), },
761 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::LiteralLet,&Token::Pat(ref pattern),&Token::MaybeTyAscription(ref option_type),&Token::MaybeInitExpr(ref option_expr),&Token::Semicolon) =>
	Token::Let(StmtKind::Let(pattern.clone(),option_type.clone(),option_expr.clone())),
_ => panic!(""), },
762 => match &state.values[0] {
&Token::LitByte => Token::Lit(Rc::new(state.values[0].clone())),
_ => panic!(""), },
763 => match &state.values[0] {
&Token::LitChar(_) => Token::Lit(Rc::new(state.values[0].clone())),
_ => panic!(""), },
764 => match &state.values[0] {
&Token::LitInteger(_) => Token::Lit(Rc::new(state.values[0].clone())),
_ => panic!(""), },
765 => match &state.values[0] {
&Token::LitFloat => Token::Lit(Rc::new(state.values[0].clone())),
_ => panic!(""), },
766 => match &state.values[0] {
&Token::True => Token::Lit(Rc::new(state.values[0].clone())),
_ => panic!(""), },
767 => match &state.values[0] {
&Token::False => Token::Lit(Rc::new(state.values[0].clone())),
_ => panic!(""), },
768 => match &state.values[0] {
&Token::Str(_) => Token::Lit(Rc::new(state.values[0].clone())),
_ => panic!(""), },
769 => match &state.values[0] {
&Token::LitStr(ref string) => Token::Str(string.clone()),
_ => panic!(""), },
770 => match &state.values[0] {
&Token::LitStrRaw => Token::Str(String::from("FIXME")),
_ => panic!(""), },
771 => match &state.values[0] {
&Token::LitByteStr => Token::Str(String::from("FIXME")),
_ => panic!(""), },
772 => match &state.values[0] {
&Token::LitByteStrRaw => Token::Str(String::from("FIXME")),
_ => panic!(""), },
773 => match () {
() => Token::MaybeIdent,
_ => panic!(""), },
774 => match &state.values[0] {
&Token::Ident(_) => Token::MaybeIdent,
_ => panic!(""), },
775 => match &state.values[0] {
&Token::LiteralIdent(ref s) => Token::Ident(s.clone()),
_ => panic!(""), },
776 => match &state.values[0] {
&Token::Catch => Token::Ident(String::from("catch")),
_ => panic!(""), },
777 => match &state.values[0] {
&Token::DEFAULT => Token::Ident(String::from("default")),
_ => panic!(""), },
778 => match &state.values[0] {
&Token::Union => Token::Ident(String::from("union")),
_ => panic!(""), },
779 => match &state.values[0] {
&Token::LE => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
780 => match &state.values[0] {
&Token::EqualEqual => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
781 => match &state.values[0] {
&Token::NE => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
782 => match &state.values[0] {
&Token::GE => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
783 => match &state.values[0] {
&Token::AndAnd => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
784 => match &state.values[0] {
&Token::OrOr => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
785 => match &state.values[0] {
&Token::LArrow => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
786 => match &state.values[0] {
&Token::MinusEqual => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
787 => match &state.values[0] {
&Token::AndEqual => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
788 => match &state.values[0] {
&Token::OrEqual => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
789 => match &state.values[0] {
&Token::PlusEqual => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
790 => match &state.values[0] {
&Token::StarEqual => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
791 => match &state.values[0] {
&Token::SlashEqual => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
792 => match &state.values[0] {
&Token::CaretEqual => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
793 => match &state.values[0] {
&Token::PercentEqual => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
794 => match &state.values[0] {
&Token::DotDot => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
795 => match &state.values[0] {
&Token::DotDotDot => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
796 => match &state.values[0] {
&Token::ModSep => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
797 => match &state.values[0] {
&Token::RArrow => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
798 => match &state.values[0] {
&Token::FatArrow => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
799 => match &state.values[0] {
&Token::LitByte => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
800 => match &state.values[0] {
&Token::LitChar(_) => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
801 => match &state.values[0] {
&Token::LitInteger(_) => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
802 => match &state.values[0] {
&Token::LitFloat => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
803 => match &state.values[0] {
&Token::LitStr(_) => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
804 => match &state.values[0] {
&Token::LitStrRaw => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
805 => match &state.values[0] {
&Token::LitByteStr => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
806 => match &state.values[0] {
&Token::LitByteStrRaw => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
807 => match &state.values[0] {
&Token::LiteralIdent(_) => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
808 => match &state.values[0] {
&Token::Underscore => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
809 => match &state.values[0] {
&Token::LiteralLifetime(_) => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
810 => match &state.values[0] {
&Token::LittleSelf => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
811 => match &state.values[0] {
&Token::Static => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
812 => match &state.values[0] {
&Token::As => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
813 => match &state.values[0] {
&Token::Break => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
814 => match &state.values[0] {
&Token::Catch => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
815 => match &state.values[0] {
&Token::Crate => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
816 => match &state.values[0] {
&Token::DEFAULT => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
817 => match &state.values[0] {
&Token::Else => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
818 => match &state.values[0] {
&Token::Enum => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
819 => match &state.values[0] {
&Token::Extern => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
820 => match &state.values[0] {
&Token::False => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
821 => match &state.values[0] {
&Token::FN => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
822 => match &state.values[0] {
&Token::For => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
823 => match &state.values[0] {
&Token::If => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
824 => match &state.values[0] {
&Token::Impl => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
825 => match &state.values[0] {
&Token::In => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
826 => match &state.values[0] {
&Token::LiteralLet => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
827 => match &state.values[0] {
&Token::Loop => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
828 => match &state.values[0] {
&Token::Match => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
829 => match &state.values[0] {
&Token::Mod => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
830 => match &state.values[0] {
&Token::Move => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
831 => match &state.values[0] {
&Token::Mut => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
832 => match &state.values[0] {
&Token::Pub => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
833 => match &state.values[0] {
&Token::Ref => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
834 => match &state.values[0] {
&Token::Return => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
835 => match &state.values[0] {
&Token::Struct => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
836 => match &state.values[0] {
&Token::Super => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
837 => match &state.values[0] {
&Token::True => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
838 => match &state.values[0] {
&Token::Trait => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
839 => match &state.values[0] {
&Token::Type => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
840 => match &state.values[0] {
&Token::Union => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
841 => match &state.values[0] {
&Token::Unsafe => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
842 => match &state.values[0] {
&Token::Use => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
843 => match &state.values[0] {
&Token::While => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
844 => match &state.values[0] {
&Token::Yield => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
845 => match &state.values[0] {
&Token::Continue => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
846 => match &state.values[0] {
&Token::BOX => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
847 => match &state.values[0] {
&Token::Const => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
848 => match &state.values[0] {
&Token::Where => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
849 => match &state.values[0] {
&Token::Typeof => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
850 => match &state.values[0] {
&Token::InnerDocComment => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
851 => match &state.values[0] {
&Token::OuterDocComment(_) => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
852 => match &state.values[0] {
&Token::Shebang => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
853 => match &state.values[0] {
&Token::StaticLifetime => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
854 => match &state.values[0] {
&Token::Semicolon => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
855 => match &state.values[0] {
&Token::Comma => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
856 => match &state.values[0] {
&Token::Dot => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
857 => match &state.values[0] {
&Token::At => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
858 => match &state.values[0] {
&Token::NumberSign => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
859 => match &state.values[0] {
&Token::Colon => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
860 => match &state.values[0] {
&Token::Equal => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
861 => match &state.values[0] {
&Token::QuestionMark => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
862 => match &state.values[0] {
&Token::Bang => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
863 => match &state.values[0] {
&Token::LT => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
864 => match &state.values[0] {
&Token::GT => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
865 => match &state.values[0] {
&Token::Minus => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
866 => match &state.values[0] {
&Token::Ampersand => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
867 => match &state.values[0] {
&Token::Vertical => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
868 => match &state.values[0] {
&Token::Plus => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
869 => match &state.values[0] {
&Token::Star => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
870 => match &state.values[0] {
&Token::Slash => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
871 => match &state.values[0] {
&Token::Caret => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
872 => match &state.values[0] {
&Token::Percent => Token::UnpairedToken(Rc::new(state.values[0].clone())),
_ => panic!(""), },
873 => match () {
() => Token::TokenTrees(vec![]),
_ => panic!(""), },
874 => match (&state.values[0],&state.values[1]) {
(&Token::TokenTrees(ref trees),&Token::TokenTree(ref token)) => Token::TokenTrees({let mut new  =  trees.clone();
new.push(token.clone());; new}),
_ => panic!(""), },
875 => match &state.values[0] {
&Token::DelimitedTokenTrees(ref trees) => Token::TokenTree(trees.clone()),
_ => panic!(""), },
876 => match &state.values[0] {
&Token::UnpairedToken(ref token) => Token::TokenTree(token.clone()),
_ => panic!(""), },
877 => match &state.values[0] {
&Token::ParensDelimitedTokenTrees(ref trees) => Token::DelimitedTokenTrees(Rc::new(state.values[0].clone())),
_ => panic!(""), },
878 => match &state.values[0] {
&Token::BracesDelimitedTokenTrees(ref trees) => Token::DelimitedTokenTrees(Rc::new(state.values[0].clone())),
_ => panic!(""), },
879 => match &state.values[0] {
&Token::BracketsDelimitedTokenTrees(ref trees) => Token::DelimitedTokenTrees(Rc::new(state.values[0].clone())),
_ => panic!(""), },
880 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LPar,&Token::TokenTrees(ref trees),&Token::RPar) => Token::ParensDelimitedTokenTrees(trees.clone()),
_ => panic!(""), },
881 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBrace,&Token::TokenTrees(ref trees),&Token::RBrace) => Token::BracesDelimitedTokenTrees(trees.clone()),
_ => panic!(""), },
882 => match (&state.values[0],&state.values[1],&state.values[2]) {
(&Token::LBracket,&Token::TokenTrees(ref trees),&Token::RBracket) => Token::BracketsDelimitedTokenTrees(trees.clone()),
_ => panic!(""), },
883 => match &state.values[0] {
&Token::NoSpace => Token::MaybeSpace,
_ => panic!(""), },
884 => match () {
() => Token::MaybeSpace,
_ => panic!(""), },
885 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Terminal,&Token::Ident(ref id),&Token::LBrace,&Token::MaybeTerminalItems(ref items),&Token::RBrace) => Token::ItemTerminal(ItemKind::Terminal(id.clone(),None,items.clone())),
_ => panic!(""), },
886 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::Terminal,&Token::Ident(ref id),&Token::LPar,&Token::MaybeTySums(_),&Token::RPar,&Token::LBrace,&Token::MaybeTerminalItems(ref items),&Token::RBrace) => Token::ItemTerminal(ItemKind::Terminal(id.clone(),Some(Rc::new(state.values[3].clone())),items.clone())),
_ => panic!(""), },
887 => match &state.values[0] {
&Token::TerminalItems(ref items) => Token::MaybeTerminalItems(items.clone()),
_ => panic!(""), },
888 => match () {
() => Token::MaybeTerminalItems(vec![]),
_ => panic!(""), },
889 => match &state.values[0] {
&Token::TerminalItem(ref item) => Token::TerminalItems(vec![item.clone()]),
_ => panic!(""), },
890 => match (&state.values[0],&state.values[1]) {
(&Token::TerminalItem(ref item),&Token::TerminalItems(ref items)) => Token::TerminalItems({let mut new  =  vec![item.clone()];; new}),//FIXME
_ => panic!(""), },
891 => match &state.values[0] {
&Token::ItemFn(ref item) => Token::TerminalItem(item.clone()),
_ => panic!(""), },
892 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4]) {
(&Token::Nonterminal,&Token::Ident(ref id),&Token::LBrace,&Token::MatchClauses(ref clauses),&Token::RBrace) => Token::ItemNonterminal(ItemKind::Nonterminal(id.clone(),None,clauses.clone())),
_ => panic!(""), },
893 => match (&state.values[0],&state.values[1],&state.values[2],&state.values[3],&state.values[4],&state.values[5],&state.values[6],&state.values[7]) {
(&Token::Nonterminal,&Token::Ident(ref id),&Token::LPar,&Token::MaybeTySums(_),&Token::RPar,&Token::LBrace,&Token::MatchClauses(ref clauses),&Token::RBrace) => Token::ItemNonterminal(ItemKind::Nonterminal(id.clone(),Some(Rc::new(state.values[3].clone())),clauses.clone())),
_ => panic!(""), },
_ => panic!(""), } }//compute_value
fn table_terminal(token_index:usize)->bool { match token_index {
1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32|33|34|35|36|37|38|39|40|41|42|43|44|45|46|47|48|49|50|51|52|53|54|55|56|57|58|59|60|61|62|63|64|65|66|67|68|69|70|71|72|73|74|75|76|77|78|79|80|81|82|83|84|85|86|87|88|89|90|91|92|93|94|95|96|97|98|99|100|101|102|103|104 => true,
0|105|106|107|108|109|110|111|112|113|114|115|116|117|118|119|120|121|122|123|124|125|126|127|128|129|130|131|132|133|134|135|136|137|138|139|140|141|142|143|144|145|146|147|148|149|150|151|152|153|154|155|156|157|158|159|160|161|162|163|164|165|166|167|168|169|170|171|172|173|174|175|176|177|178|179|180|181|182|183|184|185|186|187|188|189|190|191|192|193|194|195|196|197|198|199|200|201|202|203|204|205|206|207|208|209|210|211|212|213|214|215|216|217|218|219|220|221|222|223|224|225|226|227|228|229|230|231|232|233|234|235|236|237|238|239|240|241|242|243|244|245|246|247|248|249|250|251|252|253|254|255|256|257|258|259|260|261|262|263|264|265|266|267|268|269|270|271|272|273|274|275|276|277|278|279|280|281|282|283|284|285|286|287|288|289|290|291|292|293|294|295|296|297|298|299|300|301|302|303|304|305|306|307|308|309|310|311|312|313|314|315|316|317|318|319|320|321|322 => false,
_ => panic!("table_terminal"), } }//table_terminal
fn table_priority(a:usize, b:usize) -> Option<Ordering> { match (a,b) {
(492,492) => Some(Ordering::Equal),
(492,507) => Some(Ordering::Less),
(492,551) => Some(Ordering::Equal),
(492,566) => Some(Ordering::Less),
(492,611) => Some(Ordering::Equal),
(492,626) => Some(Ordering::Less),
(507,492) => Some(Ordering::Greater),
(507,507) => Some(Ordering::Equal),
(507,551) => Some(Ordering::Greater),
(507,566) => Some(Ordering::Equal),
(507,611) => Some(Ordering::Greater),
(507,626) => Some(Ordering::Equal),
(551,492) => Some(Ordering::Equal),
(551,507) => Some(Ordering::Less),
(551,551) => Some(Ordering::Equal),
(551,566) => Some(Ordering::Less),
(551,611) => Some(Ordering::Equal),
(551,626) => Some(Ordering::Less),
(566,492) => Some(Ordering::Greater),
(566,507) => Some(Ordering::Equal),
(566,551) => Some(Ordering::Greater),
(566,566) => Some(Ordering::Equal),
(566,611) => Some(Ordering::Greater),
(566,626) => Some(Ordering::Equal),
(611,492) => Some(Ordering::Equal),
(611,507) => Some(Ordering::Less),
(611,551) => Some(Ordering::Equal),
(611,566) => Some(Ordering::Less),
(611,611) => Some(Ordering::Equal),
(611,626) => Some(Ordering::Less),
(626,492) => Some(Ordering::Greater),
(626,507) => Some(Ordering::Equal),
(626,551) => Some(Ordering::Greater),
(626,566) => Some(Ordering::Equal),
(626,611) => Some(Ordering::Greater),
(626,626) => Some(Ordering::Equal),
_ => None, } }//table_priority
fn table_associativity(rule:usize) -> Option<Associativity> { match rule {
_ => None, } }//table_associativity
fn to_usize(token:&Token) -> usize { match token { &Token::DummyStart => 0,
&Token::Static => 1,
&Token::Mut => 2,
&Token::Const => 3,
&Token::Crate => 4,
&Token::Extern => 5,
&Token::As => 6,
&Token::Struct => 7,
&Token::Enum => 8,
&Token::Union => 9,
&Token::Mod => 10,
&Token::Unsafe => 11,
&Token::FN => 12,
&Token::Pub => 13,
&Token::LittleSelf => 14,
&Token::Type => 15,
&Token::For => 16,
&Token::Trait => 17,
&Token::DEFAULT => 18,
&Token::Impl => 19,
&Token::Where => 20,
&Token::Super => 21,
&Token::BOX => 22,
&Token::Ref => 23,
&Token::Typeof => 24,
&Token::StaticLifetime => 25,
&Token::Continue => 26,
&Token::Return => 27,
&Token::Break => 28,
&Token::Yield => 29,
&Token::Move => 30,
&Token::Match => 31,
&Token::If => 32,
&Token::Else => 33,
&Token::LiteralLet => 34,
&Token::While => 35,
&Token::Loop => 36,
&Token::In => 37,
&Token::True => 38,
&Token::False => 39,
&Token::Catch => 40,
&Token::Use => 41,
&Token::Terminal => 42,
&Token::Nonterminal => 43,
&Token::ShebangLine => 44,
&Token::LitInteger(_) => 45,
&Token::LiteralLifetime(_) => 46,
&Token::LitByte => 47,
&Token::LitChar(_) => 48,
&Token::LitFloat => 49,
&Token::LitStr(_) => 50,
&Token::LitStrRaw => 51,
&Token::LitByteStr => 52,
&Token::LitByteStrRaw => 53,
&Token::NoSpace => 54,
&Token::InnerDocComment => 55,
&Token::OuterDocComment(_) => 56,
&Token::LiteralIdent(_) => 57,
&Token::Shebang => 58,
&Token::NumberSign => 59,
&Token::FatArrow => 60,
&Token::EqualEqual => 61,
&Token::NE => 62,
&Token::Equal => 63,
&Token::LArrow => 64,
&Token::RArrow => 65,
&Token::LE => 66,
&Token::GE => 67,
&Token::MinusEqual => 68,
&Token::AndEqual => 69,
&Token::OrEqual => 70,
&Token::PlusEqual => 71,
&Token::StarEqual => 72,
&Token::SlashEqual => 73,
&Token::CaretEqual => 74,
&Token::PercentEqual => 75,
&Token::Underscore => 76,
&Token::OrOr => 77,
&Token::Vertical => 78,
&Token::Comma => 79,
&Token::AndAnd => 80,
&Token::Ampersand => 81,
&Token::DotDotDot => 82,
&Token::DotDot => 83,
&Token::Dot => 84,
&Token::ModSep => 85,
&Token::Colon => 86,
&Token::Caret => 87,
&Token::Slash => 88,
&Token::Percent => 89,
&Token::Semicolon => 90,
&Token::Bang => 91,
&Token::At => 92,
&Token::Star => 93,
&Token::QuestionMark => 94,
&Token::LBracket => 95,
&Token::RBracket => 96,
&Token::LPar => 97,
&Token::RPar => 98,
&Token::LBrace => 99,
&Token::RBrace => 100,
&Token::LT => 101,
&Token::GT => 102,
&Token::Plus => 103,
&Token::Minus => 104,
&Token::WholeCrate(_) => 105,
&Token::MaybeShebang => 106,
&Token::MaybeInnerAttrs => 107,
&Token::InnerAttrs => 108,
&Token::InnerAttr => 109,
&Token::MaybeOuterAttrs(_) => 110,
&Token::OuterAttrs(_) => 111,
&Token::OuterAttr(_) => 112,
&Token::MetaItem(_) => 113,
&Token::MetaSeq(_) => 114,
&Token::MaybeModItems(_) => 115,
&Token::ModItems(_) => 116,
&Token::AttrsAndVis(_) => 117,
&Token::ModItem(_,_) => 118,
&Token::Item(_) => 119,
&Token::StmtItem(_) => 120,
&Token::ItemStatic => 121,
&Token::ItemConst => 122,
&Token::ItemMacro(_) => 123,
&Token::ViewItem(_) => 124,
&Token::ExternFnItem => 125,
&Token::UseItem(_) => 126,
&Token::ViewPath(_) => 127,
&Token::BlockItem(_) => 128,
&Token::MaybeTyAscription(_) => 129,
&Token::MaybeInitExpr(_) => 130,
&Token::ItemStruct(_) => 131,
&Token::StructDeclArgs(_) => 132,
&Token::StructTupleArgs => 133,
&Token::StructDeclFields(_) => 134,
&Token::StructDeclField(_,_) => 135,
&Token::StructTupleFields => 136,
&Token::StructTupleField => 137,
&Token::ItemEnum(_) => 138,
&Token::EnumDefs(_) => 139,
&Token::EnumDef(_,_) => 140,
&Token::EnumArgs(_) => 141,
&Token::ItemUnion => 142,
&Token::ItemMod => 143,
&Token::ItemForeignMod => 144,
&Token::MaybeAbi => 145,
&Token::MaybeForeignItems => 146,
&Token::ForeignItems => 147,
&Token::ForeignItem => 148,
&Token::ItemForeignStatic => 149,
&Token::ItemForeignFn => 150,
&Token::FnDeclAllowVariadic => 151,
&Token::FnParamsAllowVariadic => 152,
&Token::Visibility => 153,
&Token::IdentsOrSelf(_) => 154,
&Token::IdentOrSelf(_) => 155,
&Token::ItemType => 156,
&Token::ForSized => 157,
&Token::ItemTrait => 158,
&Token::MaybeTraitItems => 159,
&Token::TraitItems => 160,
&Token::TraitItem => 161,
&Token::TraitConst => 162,
&Token::MaybeConstDefault => 163,
&Token::TraitType => 164,
&Token::MaybeUnsafe => 165,
&Token::MaybeDefaultMaybeUnsafe => 166,
&Token::TraitMethod => 167,
&Token::TypeMethod => 168,
&Token::Method => 169,
&Token::ImplMethod(_) => 170,
&Token::ItemImpl(_) => 171,
&Token::MaybeImplItems(_) => 172,
&Token::ImplItems(_) => 173,
&Token::ImplItem(_) => 174,
&Token::MaybeDefault => 175,
&Token::ImplConst => 176,
&Token::ImplType => 177,
&Token::ItemFn(_) => 178,
&Token::ItemUnsafeFn => 179,
&Token::FnDecl(_,_) => 180,
&Token::FnDeclWithSelf(_,_,_,_,_,_) => 181,
&Token::FnDeclWithSelfAllowAnonParams => 182,
&Token::FnParams(_) => 183,
&Token::FnAnonParams => 184,
&Token::FnParamsWithSelf(_,_,_,_,_) => 185,
&Token::FnAnonParamsWithSelf => 186,
&Token::MaybeParams(_) => 187,
&Token::Params(_) => 188,
&Token::Param(_,_) => 189,
&Token::InferrableParams(_) => 190,
&Token::InferrableParam(_,_) => 191,
&Token::MaybeCommaParams(_) => 192,
&Token::MaybeCommaAnonParams => 193,
&Token::MaybeAnonParams => 194,
&Token::AnonParams => 195,
&Token::AnonParam => 196,
&Token::AnonParamsAllowVariadicTail => 197,
&Token::NamedArg => 198,
&Token::RetTy(_) => 199,
&Token::GenericParams(_,_) => 200,
&Token::MaybeWhereClause => 201,
&Token::WhereClause => 202,
&Token::WherePredicates => 203,
&Token::WherePredicate => 204,
&Token::MaybeForLifetimes => 205,
&Token::TyParams(_) => 206,
&Token::PathNoTypesAllowed(_) => 207,
&Token::PathGenericArgsWithoutColons(_) => 208,
&Token::GenericArgs(_) => 209,
&Token::GenericValues(_) => 210,
&Token::MaybeTySumsAndOrBindings(_) => 211,
&Token::MaybeBindings => 212,
&Token::Pat(_) => 213,
&Token::PatsOr(_) => 214,
&Token::BindingMode(_) => 215,
&Token::LitOrPath(_) => 216,
&Token::PatField => 217,
&Token::PatFields => 218,
&Token::PatStruct => 219,
&Token::PatTup(_) => 220,
&Token::PatTupElts(_) => 221,
&Token::PatVec => 222,
&Token::PatVecElts => 223,
&Token::Ty(_) => 224,
&Token::TyPrim(_) => 225,
&Token::TyBareFn => 226,
&Token::TyFnDecl => 227,
&Token::TyClosure => 228,
&Token::ForInType => 229,
&Token::ForInTypeSuffix => 230,
&Token::MaybeMut(_) => 231,
&Token::MaybeMutOrConst => 232,
&Token::TyQualifiedPathAndGenericValues => 233,
&Token::TyQualifiedPath => 234,
&Token::MaybeTySums(_) => 235,
&Token::TySums(_) => 236,
&Token::TySum(_) => 237,
&Token::TySumElt(_) => 238,
&Token::TyPrimSum(_) => 239,
&Token::TyPrimSumElt(_) => 240,
&Token::MaybeTyParamBounds => 241,
&Token::TyParamBounds => 242,
&Token::Boundseq => 243,
&Token::Polybound => 244,
&Token::Bindings => 245,
&Token::Binding => 246,
&Token::TyParam(_) => 247,
&Token::MaybeBounds => 248,
&Token::Bounds => 249,
&Token::Bound => 250,
&Token::MaybeLTBounds => 251,
&Token::LTBounds => 252,
&Token::MaybeTyDefault => 253,
&Token::MaybeLifetimes => 254,
&Token::Lifetimes(_) => 255,
&Token::LifetimeAndBounds(_) => 256,
&Token::Lifetime(_) => 257,
&Token::TraitRef(_) => 258,
&Token::InnerAttrsAndBlock(_,_) => 259,
&Token::Block(_,_) => 260,
&Token::MaybeStmts(_,_) => 261,
&Token::Stmts(_) => 262,
&Token::Stmt(_) => 263,
&Token::MaybeExprs(_) => 264,
&Token::MaybeExpr(_) => 265,
&Token::Exprs(_) => 266,
&Token::PathExpr(_) => 267,
&Token::PathGenericArgsWithColons(_) => 268,
&Token::MacroExpr(_,_,_) => 269,
&Token::NonblockExpr(_) => 270,
&Token::Expr(_) => 271,
&Token::ExprNostruct(_) => 272,
&Token::NonblockPrefixExprNostruct(_) => 273,
&Token::NonblockPrefixExpr(_) => 274,
&Token::ExprQualifiedPath => 275,
&Token::MaybeQPathParams => 276,
&Token::MaybeAsTraitRef => 277,
&Token::LambdaExpr(_) => 278,
&Token::LambdaExprNoFirstBar(_) => 279,
&Token::LambdaExprNostruct(_) => 280,
&Token::LambdaExprNostructNoFirstBar(_) => 281,
&Token::VecExpr => 282,
&Token::StructExprFields(_) => 283,
&Token::MaybeFieldInits(_) => 284,
&Token::FieldInits(_) => 285,
&Token::FieldInit(_,_) => 286,
&Token::DefaultFieldInit => 287,
&Token::BlockExpr(_) => 288,
&Token::FullBlockExpr(_) => 289,
&Token::BlockExprDot => 290,
&Token::ExprMatch(_,_) => 291,
&Token::MatchClauses(_) => 292,
&Token::MatchClause(_,_,_) => 293,
&Token::NonblockMatchClause(_,_,_) => 294,
&Token::BlockMatchClause(_,_,_) => 295,
&Token::MaybeGuard => 296,
&Token::ExprIf(_,_,_) => 297,
&Token::ExprIfLet(_,_,_,_) => 298,
&Token::BlockOrIf(_) => 299,
&Token::ExprWhile(_,_) => 300,
&Token::ExprWhileLet => 301,
&Token::ExprLoop => 302,
&Token::ExprFor(_,_,_) => 303,
&Token::MaybeLabel => 304,
&Token::Let(_) => 305,
&Token::Lit(_) => 306,
&Token::Str(_) => 307,
&Token::MaybeIdent => 308,
&Token::Ident(_) => 309,
&Token::UnpairedToken(_) => 310,
&Token::TokenTrees(_) => 311,
&Token::TokenTree(_) => 312,
&Token::DelimitedTokenTrees(_) => 313,
&Token::ParensDelimitedTokenTrees(_) => 314,
&Token::BracesDelimitedTokenTrees(_) => 315,
&Token::BracketsDelimitedTokenTrees(_) => 316,
&Token::MaybeSpace => 317,
&Token::ItemTerminal(_) => 318,
&Token::MaybeTerminalItems(_) => 319,
&Token::TerminalItems(_) => 320,
&Token::TerminalItem(_) => 321,
&Token::ItemNonterminal(_) => 322,
} }//to_usize
}//impl




#[derive(Debug)]
struct Rule
{
	//left
	//right: Vec<usize>,
	patterns: Vec<PatKind>,//[Pat(Path(LitOrPath("NoSpace")))]  ,  Pat(Enum(PathExpr("MaybeModItems"), PatTup([Pat(Path(LitOrPath("items")))])))
	expression: Rc<Token>,//NonblockExpr
	priority: Option<String>,
}

#[derive(Debug)]
struct TokenInfo
{
	id: String,
	//type_arguments: Vec<Rc<Token>>,
	type_arguments: Vec<TyLf>,
	is_terminal: bool,
	re: Option<String>,
	fn_match: Option<ItemKind>,
	rules: Vec<Rule>,
}

struct Compiler<'a>
{
	source: &'a Token,
	token_info: Vec<TokenInfo>,
	first_nonterminal: Option<usize>,
	token_name_to_index: HashMap<String,usize>,//already with the +1
	ordering: HashMap<(String,String),Ordering>,
	ignore_res: Vec<(usize,String)>,
}

impl<'a> Compiler<'a>
{
	fn process_token(&mut self,token:&Token)
	{
		//println!(">>process_token {:?}",token);
		match token
		{
			&Token::WholeCrate(ref items) =>
			{
				for item in items
				{
					self.process_token(item);
				}
			},
			&Token::ModItem(ref attributes,ref item) =>
			{
				//self.process_token(item);
				match item
				{
					&ItemKind::Fixme => println!("fixme item={:?}",item),
					&ItemKind::Macro(ref path, ref id, ref tree) =>
					{
						match (path.as_ref(),tree.as_ref())
						{
							(&Token::PathExpr(PathKind::Ident(ref s)),&Token::ParensDelimitedTokenTrees(ref data)) =>
							{
								if s=="re_terminal"
								{
									//println!("re_terminal macro = {:?}",item);
									let mut comma_index=0;
									while comma_index<data.len() && *data[comma_index]!=Token::Comma
									{
										comma_index+=1;
									}
									if comma_index<data.len()
									{
										match (data[0].as_ref(),data[comma_index+1].as_ref())
										{
											(&Token::LiteralIdent(ref id),&Token::LitStr(ref re)) =>
											{
												//let type_arguments=if let &Token::DelimitedTokenTrees(ref trees)=data[1].as_ref()
												//{
												//	if let &Token::ParensDelimitedTokenTrees(ref data_types)=trees.as_ref()
												//	{
												//		let mut new=vec![];
												//		for dt in data_types
												//		{
												//			if let &Token::LiteralIdent(ref s)=dt.as_ref()
												//			{
												//				//println!("Got type {}",s);
												//				new.push(TyLf::Type(TyKind::Path(PathWKind::Ident(s.clone()))));
												//			}
												//			else
												//			{
												//				panic!("problem parsing types in macro {:?}",item);
												//			}
												//		}
												//		new
												//	}
												//	else
												//	{
												//		panic!("weird tree in {:?}",item);
												//	}
												//}
												let type_arguments=if let &Token::ParensDelimitedTokenTrees(ref data_types)=data[1].as_ref()
												{
													let mut new=vec![];
													for dt in data_types
													{
														if let &Token::LiteralIdent(ref s)=dt.as_ref()
														{
															//println!("Got type {}",s);
															new.push(TyLf::Type(TyKind::Path(PathWKind::Ident(s.clone()))));
														}
														else
														{
															panic!("problem parsing types in macro {:?}",item);
														}
													}
													new
												}
												else
												{
													vec![]
												};
												if id=="_"
												{
													self.ignore_res.push((self.token_info.len(),re[1..re.len()-1].to_string()));
												}
												else
												{
													self.token_info.push(TokenInfo{
														id:id.clone(),
														//type_string:String::from("()"),
														type_arguments,
														is_terminal: true,
														re:Some(re[1..re.len()-1].to_string()),
														fn_match: None,
														rules: vec![],
													});
												}
											},
											_ => println!("incorrect data in re_terminal"),
										}
									}
									else
									{
										println!("incorrect data in re_terminal");
									}
								}
								else if s=="ordering"
								{
									let mut order=vec![];
									for elem in data
									{
										match elem.as_ref()
										{
											&Token::LiteralIdent(ref id) => order.push(id.clone()),
											&Token::Comma => (),
											_ => panic!("incorrect token in ordering! {:?}",elem),
										};
									}
									for i in 0..order.len()
									{
										for j in 0..order.len()
										{
											self.ordering.insert((order[i].clone(),order[j].clone()),i.cmp(&j));
										}
									}
								}
							},
							_ => println!("ignoring macro {:?}",token),
						};
					}
					//&ItemKind::FN(ref ) => (),
					&ItemKind::Terminal(ref id, ref ty, ref items) =>
					{
						let type_arguments= match ty
						{
							&None => vec![],
							&Some(ref mts) => match mts.as_ref()
							{
								&Token::MaybeTySums(ref types) => types.clone(),
								_ => panic!(""),
							}
						};
						let mut fn_match=None;
						for item in items
						{
							match item
							{
								&ItemKind::FN(ref name, ref lifetimes,ref _gp,ref _params,ref _oret,ref _bs,ref _be) =>
								{
									if name=="_match"
									{
										fn_match=Some(item.clone());
									}
									else
									{
										panic!("received fn {} is terminal {}",name,id);
									}
								},
								_ => panic!("We do not know what to do with item {:?} in terminal {}",item,id),
							};
						}
						self.token_info.push(TokenInfo{
							id:id.clone(),
							//type_string:String::from("()"),
							type_arguments,
							is_terminal: true,
							re: None,
							fn_match,
							rules: vec![],
						});
					},
					&ItemKind::Nonterminal(ref id, ref ty, ref clauses) =>
					{
						if let None=self.first_nonterminal
						{
							self.first_nonterminal=Some(self.token_info.len());
						}
						let mut rules=vec![];
						for clause in clauses
						{
							//println!("Found clause {:?}",clause);
							if let &Token::MatchClause(ref attributes,ref patterns,ref expression)=clause.as_ref()
							{
								let mut rule_patterns =vec![];
								if let &PatKind::Tuple(ref patterns)=patterns
								{
									//rule_patterns.push(pat.clone());
									rule_patterns=patterns.clone();
								}
								let mut priority=None;
								for attr in attributes
								{
									if let &AttrKind::Sequence(ref attr_name, ref seq)=attr
									{
										if attr_name=="priority"
										{
											if seq.len()!=1
											{
												panic!("there must be exactly one priority flag ({:?})",attr);
											}
											if let AttrKind::Flag(ref p_flag)=seq[0]
											{
												priority=Some(p_flag.clone());
											}
											else
											{
												panic!("I do not understand this priority {:?}",attr);
											}
										}
									}
								}
								rules.push(Rule{
									//right: vec![],
									patterns: rule_patterns,
									expression: expression.clone(),
									priority,
								});
							}
						}
						let type_arguments= match ty
						{
							&None => vec![],
							&Some(ref mts) => match mts.as_ref()
							{
								&Token::MaybeTySums(ref types) => types.clone(),
								_ => panic!(""),
							}
						};
						self.token_info.push(TokenInfo{
							id:id.clone(),
							//type_string:String::from("()"),
							type_arguments,
							is_terminal: false,
							re: None,
							fn_match: None,
							rules,
						});
					},
					_ =>
					{
						for attr in attributes
						{
							println!("{}",attr);
						}
						println!("{}",item);
					},
					//&ItemKind::View(ref view) => println!("{}",view),
					//&ItemKind::Enum(ref id, ref params, ref defs) =>
					//{
					//	print!("enum {}",id);
					//	if params.len()>0
					//	{
					//		print!("({})",params.join(","));
					//	}
					//	println!("{{");
					//	for &(ref name,ref tys) in defs
					//	{
					//		print!("{}",name);
					//		if tys.len()>0
					//		{
					//			print!("({})",tys.iter().map(|t|t.to_string()).collect::<Vec<String>>().join(","))
					//		}
					//		println!(",");
					//	}
					//	println!("}}");
					//},
				}
			},
			//&Token::ItemMacro(ref path, ref id, ref tree) =>
			//{
			//	//println!("Got macro {:?} with data {:?}",path,tree);
			//	match (path.as_ref(),tree.as_ref())
			//	{
			//		(&Token::PathExpr(PathKind::Ident(ref s)),&Token::ParensDelimitedTokenTrees(ref data)) =>
			//		{
			//			if s=="re_terminal"
			//			{
			//				let mut comma_index=0;
			//				while comma_index<data.len() && *data[comma_index]!=Token::Comma
			//				{
			//					comma_index+=1;
			//				}
			//				if comma_index<data.len()
			//				{
			//					match (data[0].as_ref(),data[comma_index+1].as_ref())
			//					{
			//						(&Token::LiteralIdent(ref id),&Token::LitStr(ref re)) =>
			//						{
			//							if id!="_"
			//							{
			//								self.token_info.push(TokenInfo{
			//									id:id.clone(),
			//									//type_string:String::from("()"),
			//									type_arguments: vec![],
			//									is_terminal: true,
			//									re:Some(re[1..re.len()-1].to_string()),
			//									fn_match: None,
			//									rules: vec![],
			//								});
			//							}
			//						},
			//						_ => println!("incorrect data in re_terminal"),
			//					}
			//				}
			//				else
			//				{
			//					println!("incorrect data in re_terminal");
			//				}
			//			}
			//			else if s=="ordering"
			//			{
			//				let mut order=vec![];
			//				for elem in data
			//				{
			//					match elem.as_ref()
			//					{
			//						&Token::LiteralIdent(ref id) => order.push(id.clone()),
			//						&Token::Comma => (),
			//						_ => panic!("incorrect token in ordering! {:?}",elem),
			//					};
			//				}
			//				for i in 0..order.len()
			//				{
			//					for j in 0..order.len()
			//					{
			//						self.ordering.insert((order[i].clone(),order[j].clone()),i.cmp(&j));
			//					}
			//				}
			//			}
			//		},
			//		_ => println!("ignoring macro {:?}",token),
			//	};
			//},
			//&Token::ItemTerminal(ref id, ref ty, ref items) =>
			//{
			//	let type_arguments= match ty
			//	{
			//		&None => vec![],
			//		&Some(ref mts) => match mts.as_ref()
			//		{
			//			&Token::MaybeTySums(ref types) => types.clone(),
			//			_ => panic!(""),
			//		}
			//	};
			//	self.token_info.push(TokenInfo{
			//		id:id.clone(),
			//		//type_string:String::from("()"),
			//		type_arguments,
			//		is_terminal: true,
			//		re: None,
			//		fn_match: None,//FIXME
			//		rules: vec![],
			//	});
			//},
			//&Token::ItemNonterminal(ref id, ref ty, ref clauses) =>
			//{
			//	if let None=self.first_nonterminal
			//	{
			//		self.first_nonterminal=Some(self.token_info.len());
			//	}
			//	let mut rules=vec![];
			//	for clause in clauses
			//	{
			//		//println!("Found clause {:?}",clause);
			//		if let &Token::MatchClause(ref attributes,ref patterns,ref expression)=clause.as_ref()
			//		{
			//			let mut rule_patterns : Vec<Rc<Token>>=vec![];
			//			if let &PatKind::Tuple(ref tuple)=patterns
			//			{
			//				if let &Token::PatTup(ref pats)=tuple.as_ref()
			//				{
			//					for pat in pats
			//					{
			//						rule_patterns.push(pat.clone());
			//					}
			//				}
			//			}
			//			let mut priority=None;
			//			for attr in attributes
			//			{
			//				if let &AttrKind::Sequence(ref attr_name, ref seq)=attr
			//				{
			//					if attr_name=="priority"
			//					{
			//						if seq.len()!=1
			//						{
			//							panic!("there must be exactly one priority flag ({:?})",attr);
			//						}
			//						if let AttrKind::Flag(ref p_flag)=seq[0]
			//						{
			//							priority=Some(p_flag.clone());
			//						}
			//						else
			//						{
			//							panic!("I do not understand this priority {:?}",attr);
			//						}
			//					}
			//				}
			//			}
			//			rules.push(Rule{
			//				//right: vec![],
			//				patterns: rule_patterns,
			//				expression: expression.clone(),
			//				priority,
			//			});
			//		}
			//	}
			//	let type_arguments= match ty
			//	{
			//		&None => vec![],
			//		&Some(ref mts) => match mts.as_ref()
			//		{
			//			&Token::MaybeTySums(ref types) => types.clone(),
			//			_ => panic!(""),
			//		}
			//	};
			//	self.token_info.push(TokenInfo{
			//		id:id.clone(),
			//		//type_string:String::from("()"),
			//		type_arguments,
			//		is_terminal: false,
			//		re: None,
			//		fn_match: None,
			//		rules,
			//	});
			//},
			//&Token::ViewItem(ref view) => println!("{}",view),
			//&Token::ItemEnum(ref id, ref params, ref defs) =>
			//{
			//	print!("enum {}",id);
			//	if params.len()>0
			//	{
			//		print!("({})",params.join(","));
			//	}
			//	println!("{{");
			//	for &(ref name,ref tys) in defs
			//	{
			//		print!("{}",name);
			//		if tys.len()>0
			//		{
			//			print!("({})",tys.iter().map(|t|t.to_string()).collect::<Vec<String>>().join(","))
			//		}
			//		println!(",");
			//	}
			//	println!("}}");
			//},
			_ => (),
		};
	}
	fn compile(&mut self)
	{
		self.process_token(self.source);
		for (i,token) in self.token_info.iter().enumerate()
		{
			//println!("token {}={:?}",i+1,token);
			self.token_name_to_index.insert(token.id.clone(),i+1);
		}
		//println!("first non-terminal={:?}",self.first_nonterminal);
		//println!("--------------------------------------");
		println!("#[derive(Clone,Debug,PartialEq)]");
		println!("enum Token{{DummyStart,");
		for token in self.token_info.iter()
		{
			if token.type_arguments.len()>0
			{
				print!("{}({}),",token.id,token.type_arguments.iter().map(|t|format!("{}",t)).collect::<Vec<String>>().join(","));
			}
			else
			{
				print!("{},",token.id);
			}
		}
		println!("}}\nimpl Default for Token {{ fn default()->Self{{Token::DummyStart}} }}");
		println!("struct ParsingTables {{ }}");
		println!("impl ParsingTablesTrait<Token> for ParsingTables {{");
		println!("fn initial()->usize {{ {} }}",self.first_nonterminal.unwrap()+1);
		println!("fn match_some(parser: &mut Parser<Token,Self>) -> Option<(usize,Token)> {{ let source=&parser.source[parser.source_index..];");
		let mut ignore_it=self.ignore_res.iter();
		let (mut ignore_pos,mut ignore_sre) = if let Some(&(pos,ref sre))=ignore_it.next()
		{
			(Some(pos),Some(sre.clone()))
		}
		else
		{
			(None,None)
		};
		for (i,token) in self.token_info.iter().enumerate()
		{
			if ignore_pos==Some(i)
			{
				if let Some(sre)=ignore_sre
				{
					println!("match {{ match parser.re(\"{}\",source) {{ None => None, Some((size,_string)) => Some((size,())) }} }}",sre);
					println!("{{ None => (), Some((size,_result)) => return Some((size,Token::DummyStart)), }};");
				}
				if let Some(&(pos,ref sre))=ignore_it.next()
				{
					//(Some(pos),Some(sre.clone()))
					ignore_pos=Some(pos);
					ignore_sre=Some(sre.clone());
				}
				else
				{
					//(None,None)
					ignore_pos=None;
					ignore_sre=None;
				};
			}
			if token.is_terminal
			{
				if let Some(ref sre)=token.re
				{
					//println!("PUT HERE THE MATCH WITH {} re={},",token.id,sre);
					if token.type_arguments.len()==0
					{
						println!("match {{ match parser.re(\"{}\",source) {{ None => None, Some((size,_string)) => Some((size,())) }} }}",sre);
						println!("{{ None => (), Some((size,_result)) => return Some((size,Token::{})), }};",token.id);
					}
					else
					{
						println!("match {{ match parser.re(\"{}\",source) {{ None => None, Some((size,string)) => Some((size,string.parse::<{}>().unwrap() )) }} }}",sre,token.type_arguments.iter().map(|t|t.to_string()).collect::<Vec<String>>().join(","));
						println!("{{ None => (), Some((size,result)) => return Some((size,Token::{}(result))), }};",token.id);
					}
				}
				else if let Some(ref fun)=token.fn_match
				{
					//println!("PUT HERE THE MATCH WITH {},",token.id);
					println!("{{ {}",fun);
					if token.type_arguments.len()==0
					{
						println!("match _match(parser,source) {{ None=>(), Some((size,_result)) => return Some((size,Token::{})), }} }};",token.id);
					}
					else
					{
						println!("match _match(parser,source) {{ None=>(), Some((size,result)) => return Some((size,Token::{}(result))), }} }};",token.id);//FIXME tuple
					}
				}
				else
				{
					panic!("terminal token {} has not matching function",token.id);
				}
			}
		}
		println!("None }}//match_some");//match_some
		println!("fn predict(parser:&mut Parser<Token,Self>,index:usize,state_index:usize,token:usize) {{ match token {{");
		let mut irule=1;
		for (i,token) in self.token_info.iter().enumerate()
		{
			if !token.is_terminal
			{
				println!("{} => {{",i+1);
				//println!("PRINT THE RULES OF TOKEN {}",token.id);
				for rule in token.rules.iter()
				{
					println!("parser.sets[index].predict(State{{rule: {} ,left: {} ,right:vec![ {} ],position:0,original_set:index,kind:EarleyKind::Predict(state_index),values:vec![Token::DummyStart; {} ],computed_value:Token::DummyStart,ambiguity_info:AmbiguityInfo::default(),}});",irule,i+1,rule.patterns.iter().map(|p|match p
					{
						&PatKind::Path(ref path) => match path
						{
							&PathKind::Ident(ref string) => self.token_name_to_index.get(string).expect(&format!("string {} not found in map",string)).to_string(),
							_ => panic!(""),
						},
						&PatKind::Enum(ref name, _ ) => match name.as_ref()
						{
							&Token::PathExpr(PathKind::Ident(ref string)) => self.token_name_to_index.get(string).expect(&format!("string {} not found in map",string)).to_string(),
							_ => panic!(""),
						},
						_ => panic!("received {:?}",p),
					}).collect::<Vec<String>>().join(","),rule.patterns.len());
					irule+=1;
				}
				println!("}}");
			}
		}
		println!("_ => panic!(\"\"), }} }}//predict");
		println!("fn compute_value(state:&mut State<Token>) {{ state.computed_value = match state.rule {{ 0 => state.values[0].clone(),");
		//println!("GO THROUGH THE RULES");
		let mut irule=1;
		for token in self.token_info.iter()
		{
			for rule in token.rules.iter()
			{
				let n=token.type_arguments.len();
				if rule.patterns.len()==0
				{
					if n==0
					{
						println!("{} => Token::{},",irule,token.id);
					}
					else if n==1
					{
						println!("{} => Token::{}({}),",irule,token.id,rule.expression);
					}
					else
					{
						let v=(0..n).map(|i| format!("x{}",i) ).collect::<Vec<String>>().join(",");
						println!("{} => {{ let ({})={}; Token::{}({}) }},",irule,v,rule.expression,token.id,v);
					}
				}
				else
				{
					let pattern_string=rule.patterns.iter().map(|p|match p
					{
						&PatKind::Path(ref path) => match path
						{
							&PathKind::Ident(ref string) =>
							{
								let index=self.token_name_to_index.get(string).expect(&format!("{} is not a token",string));
								let n=self.token_info[*index-1].type_arguments.len();
								if n==0
								{
									format!("&Token::{}",string)
								}
								else
								{
									format!("&Token::{}({})",string,(0..n).map(|_|String::from("_")).collect::<Vec<String>>().join(","))
								}
							},
							_ => panic!(""),
						},
						&PatKind::Enum(ref name, ref tuple) => match name.as_ref()
						{
							&Token::PathExpr(ref string) => format!("&Token::{}({})",string,tuple.iter().map(|x| format!("{}",x) ).collect::<Vec<String>>().join(",")),
							_ => panic!("name={:?} tuple={:?}",name,tuple),
						},
						_ => panic!("received {:?}",p),
					}).collect::<Vec<String>>().join(",");
					if rule.patterns.len()==1
					{
						println!("{} => match &state.values[0] {{",irule);
						print!("{}",pattern_string);
					}
					else
					{
						println!("{} => match ({}) {{",irule,(0..rule.patterns.len()).map(|i| format!("&state.values[{}]",i) ).collect::<Vec<String>>().join(","));
						print!("({})",pattern_string);
					}
					if n==0
					{
						//println!("({}) => Token::{},",pattern_string,token.id);
						println!(" => Token::{},",token.id);
					}
					else if n==1
					{
						//println!("({}) => Token::{}({}),",pattern_string,token.id,rule.expression);
						println!(" => Token::{}({}),",token.id,rule.expression);
					}
					else
					{
						// We may need to do unpacking if >=2
						//	https://stackoverflow.com/questions/39878382/unpacking-tuples-into-arguments
						//	https://github.com/rust-lang/rust/issues/17274
						let v=(0..n).map(|i| format!("x{}",i) ).collect::<Vec<String>>().join(",");
						println!(" => {{ let ({})={}; Token::{}({}) }},",v,rule.expression,token.id,v);
					}
					println!("_ => panic!(\"\"), }},");
				}
				irule+=1;
			}
		}
		println!("_ => panic!(\"\"), }} }}//compute_value");
		println!("fn table_terminal(token_index:usize)->bool {{ match token_index {{");
		println!("{} => true,",self.token_info.iter().enumerate().filter_map(|(i,t)|if t.is_terminal {Some((i+1).to_string())} else {None}).collect::<Vec<String>>().join("|"));
		println!("0|{} => false,",self.token_info.iter().enumerate().filter_map(|(i,t)|if !t.is_terminal {Some((i+1).to_string())} else {None}).collect::<Vec<String>>().join("|"));
		println!("_ => panic!(\"table_terminal\"), }} }}//table_terminal");
		println!("fn table_priority(a:usize, b:usize) -> Option<Ordering> {{ match (a,b) {{");
		//println!("HERE THE PRIORITIES");
		let mut irule=1;
		for ltoken in self.token_info.iter()
		{
			for lrule in ltoken.rules.iter()
			{
				if let Some(ref lorder)=lrule.priority
				{
					let mut jrule=1;
					for rtoken in self.token_info.iter()
					{
						for rrule in rtoken.rules.iter()
						{
							if let Some(ref rorder)=rrule.priority
							{
								//(6,6) => Some(Ordering::Equal),
								println!("({},{}) => Some(Ordering::{:?}),",irule,jrule,self.ordering.get(&(lorder.clone(),rorder.clone())).expect("what?"));
							}
							jrule+=1;
						}
					}
				}
				irule+=1;
			}
		}
		println!("_ => None, }} }}//table_priority");
		println!("fn table_associativity(rule:usize) -> Option<Associativity> {{ match rule {{");
		println!("_ => None, }} }}//table_associativity");
		println!("fn to_usize(token:&Token) -> usize {{ match token {{ &Token::DummyStart => 0,");
		for (i,token) in self.token_info.iter().enumerate()
		{
			if token.type_arguments.len()==0
			{
				println!("&Token::{} => {},",token.id,i+1);
			}
			else
			{
				println!("&Token::{}({}) => {},",token.id,(0..token.type_arguments.len()).map(|_|String::from("_")).collect::<Vec<String>>().join(","),i+1);
			}
		}
		println!("}} }}//to_usize");
		println!("}}//impl");//impl
	}
}

fn main()
{
	let args: Vec<String> = env::args().collect();
	//println!("{:?}", args);
	if args.len()!=2
	{
		println!("Use:\n\t{} filename",args[0]);
		return;
	}
	let mut f = File::open(&args[1]).expect("file cannot be opened");

	let mut contents = String::new();
	f.read_to_string(&mut contents).expect("something went wrong reading the file");

	//println!("With text:\n{}", contents);
	match Parser::<Token,ParsingTables>::parse(&contents,None)
	{
		Err(x) => println!("error parsing: {:?}",x),
		Ok(x) =>
		{
			//println!("parsed correctly: {:?}",x);
			let mut compiler=Compiler{
				source: &x,
				token_info: vec![],
				first_nonterminal: None,
				token_name_to_index: HashMap::new(),
				ordering: HashMap::new(),
				ignore_res: vec![],
			};
			compiler.compile();
		},
	};
}