lalrpop-0.17.2/Cargo.toml.orig000064400000000000000000000020201352730436000143240ustar0000000000000000[package] name = "lalrpop" version = "0.17.2" # LALRPOP description = "convenient LR(1) parser generator" repository = "https://github.com/lalrpop/lalrpop" readme = "../README.md" keywords = ["parser", "generator", "LR", "yacc", "grammar"] categories = ["parsing"] license = "Apache-2.0/MIT" authors = ["Niko Matsakis "] workspace = ".." exclude = ["build.rs"] [lib] doctest = false [dependencies] ascii-canvas = "2.0" atty = "0.2" bit-set = "0.5" diff = "0.1.9" docopt = "1" ena = "0.13" itertools = "0.8" regex = "1" regex-syntax = "0.6.0" petgraph = "0.4.13" serde = "1.0" serde_derive = "1.0" string_cache = "0.7.1" term = "0.5" unicode-xid = "0.1" sha2 = "0.8.0" [dev-dependencies] rand = "0.6" [dependencies.lalrpop-util] path = "../lalrpop-util" version = "0.17.2" # LALRPOP [features] # Feature used when developing LALRPOP. Tells the build script to use an existing lalrpop binary to # generate LALRPOPs own parser instead of using the saved parser. test = [] lalrpop-0.17.2/Cargo.toml0000644000000032000000000000000106240ustar00# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] name = "lalrpop" version = "0.17.2" authors = ["Niko Matsakis "] exclude = ["build.rs"] description = "convenient LR(1) parser generator" readme = "../README.md" keywords = ["parser", "generator", "LR", "yacc", "grammar"] categories = ["parsing"] license = "Apache-2.0/MIT" repository = "https://github.com/lalrpop/lalrpop" [lib] doctest = false [dependencies.ascii-canvas] version = "2.0" [dependencies.atty] version = "0.2" [dependencies.bit-set] version = "0.5" [dependencies.diff] version = "0.1.9" [dependencies.docopt] version = "1" [dependencies.ena] version = "0.13" [dependencies.itertools] version = "0.8" [dependencies.lalrpop-util] version = "0.17.2" [dependencies.petgraph] version = "0.4.13" [dependencies.regex] version = "1" [dependencies.regex-syntax] version = "0.6.0" [dependencies.serde] version = "1.0" [dependencies.serde_derive] version = "1.0" [dependencies.sha2] version = "0.8.0" [dependencies.string_cache] version = "0.7.1" [dependencies.term] version = "0.5" [dependencies.unicode-xid] version = "0.1" [dev-dependencies.rand] version = "0.6" [features] test = [] lalrpop-0.17.2/src/api/mod.rs000064400000000000000000000226441350346013400141340ustar0000000000000000use build; use log::Level; use session::{ColorConfig, Session}; use std::default::Default; use std::env; use std::env::current_dir; use std::error::Error; use std::path::{Path, PathBuf}; use std::rc::Rc; /// Configure various aspects of how LALRPOP works. /// Intended for use within a `build.rs` script. /// To get the default configuration, use `Configuration::new`. #[derive(Clone, Default)] pub struct Configuration { session: Session, } impl Configuration { /// Creates the default configuration; equivalent to `Configuration::default`. pub fn new() -> Configuration { Configuration::default() } /// Always use ANSI colors in output, even if output does not appear to be a TTY. pub fn always_use_colors(&mut self) -> &mut Configuration { self.session.color_config = ColorConfig::Yes; self } /// Never use ANSI colors in output, even if output appears to be a TTY. pub fn never_use_colors(&mut self) -> &mut Configuration { self.session.color_config = ColorConfig::No; self } /// Use ANSI colors in output if output appears to be a TTY, but /// not otherwise. This is the default. pub fn use_colors_if_tty(&mut self) -> &mut Configuration { self.session.color_config = ColorConfig::IfTty; self } /// Specify a custom directory to search for input files. This /// directory is recursively searched for `.lalrpop` files to be /// considered as input files. This configuration setting also /// impacts where output files are placed; paths are made relative /// to the input path before being resolved relative to the output /// path. By default, the input directory is the current working /// directory. pub fn set_in_dir

(&mut self, dir: P) -> &mut Self where P: Into, { self.session.in_dir = Some(dir.into()); self } /// Specify a custom directory to use when writing output files. /// By default, the output directory is the same as the input /// directory. pub fn set_out_dir

(&mut self, dir: P) -> &mut Self where P: Into, { self.session.out_dir = Some(dir.into()); self } /// Apply `cargo` directory location conventions, by setting the /// input directory to `src` and the output directory to /// `$OUT_DIR`. pub fn use_cargo_dir_conventions(&mut self) -> &mut Self { self.set_in_dir("src") .set_out_dir(env::var("OUT_DIR").unwrap()); self } /// Write output files in the same directory of the input files. /// /// If this option is enabled, you have to load the parser as a module: /// /// ```no_run /// mod parser; // synthesized from parser.lalrpop /// ``` /// /// This was the default behaviour up to version 0.15. pub fn generate_in_source_tree(&mut self) -> &mut Self { self.set_in_dir(Path::new(".")).set_out_dir(Path::new(".")) } /// If true, always convert `.lalrpop` files into `.rs` files, even if the /// `.rs` file is newer. Default is false. pub fn force_build(&mut self, val: bool) -> &mut Configuration { self.session.force_build = val; self } /// If true, print `rerun-if-changed` directives to standard output, so that /// Cargo will only rerun the build script if any of the processed /// `.lalrpop` files are changed. This option is independent of /// [`force_build`], although it would be usual to set [`force_build`] and /// [`emit_rerun_directives`] at the same time. /// /// While many build scripts will want to set this to `true`, the default is /// false, because emitting any rerun directives to Cargo will cause the /// script to only be rerun when Cargo thinks it is needed. This could lead /// to hard-to-find bugs if other parts of the build script do not emit /// directives correctly, or need to be rerun unconditionally. pub fn emit_rerun_directives(&mut self, val: bool) -> &mut Configuration { self.session.emit_rerun_directives = val; self } /// If true, emit comments into the generated code. This makes the /// generated code significantly larger. Default is false. pub fn emit_comments(&mut self, val: bool) -> &mut Configuration { self.session.emit_comments = val; self } /// If false, shrinks the generated code by removing redundant white space. /// Default is true. pub fn emit_whitespace(&mut self, val: bool) -> &mut Configuration { self.session.emit_whitespace = val; self } /// If true, emit report file about generated code. pub fn emit_report(&mut self, val: bool) -> &mut Configuration { self.session.emit_report = val; self } /// Minimal logs: only for errors that halt progress. pub fn log_quiet(&mut self) -> &mut Configuration { self.session.log.set_level(Level::Taciturn); self } /// Informative logs: give some high-level indications of /// progress (default). pub fn log_info(&mut self) -> &mut Configuration { self.session.log.set_level(Level::Informative); self } /// Verbose logs: more than info, but still not overwhelming. pub fn log_verbose(&mut self) -> &mut Configuration { self.session.log.set_level(Level::Verbose); self } /// Debug logs: better redirect this to a file. Intended for /// debugging LALRPOP itself. pub fn log_debug(&mut self) -> &mut Configuration { self.session.log.set_level(Level::Debug); self } /// Sets the features used during compilation, disables the use of cargo features. /// (Default: Loaded from `CARGO_FEATURE_{}` environment variables). pub fn set_features(&mut self, iterable: I) -> &mut Configuration where I: IntoIterator, { self.session.features = Some(iterable.into_iter().collect()); self } /// Enables "unit-testing" configuration. This is only for /// lalrpop-test. #[doc(hidden)] pub fn unit_test(&mut self) -> &mut Configuration { self.session.unit_test = true; self } /// Process all files according to the `set_in_dir` and /// `set_out_dir` configuration. pub fn process(&self) -> Result<(), Box> { let root = if let Some(ref d) = self.session.in_dir { d.as_path() } else { Path::new(".") }; self.process_dir(root) } /// Process all files in the current directory, which -- unless you /// have changed it -- is typically the root of the crate being compiled. pub fn process_current_dir(&self) -> Result<(), Box> { self.process_dir(current_dir()?) } /// Process all `.lalrpop` files in `path`. pub fn process_dir>(&self, path: P) -> Result<(), Box> { let mut session = self.session.clone(); // If in/out dir are empty, use cargo conventions by default. // See https://github.com/lalrpop/lalrpop/issues/280 if session.in_dir.is_none() { let mut in_dir = env::current_dir()?; in_dir.push("src"); session.in_dir = Some(in_dir); } if session.out_dir.is_none() { let out_dir = match env::var_os("OUT_DIR") { Some(var) => var, None => return Err("missing OUT_DIR variable")?, }; session.out_dir = Some(PathBuf::from(out_dir)); } if self.session.features.is_none() { // Pick up the features cargo sets for build scripts session.features = Some( env::vars() .filter_map(|(feature_var, _)| { let prefix = "CARGO_FEATURE_"; if feature_var.starts_with(prefix) { Some( feature_var[prefix.len()..] .replace("_", "-") .to_ascii_lowercase(), ) } else { None } }) .collect(), ); } let session = Rc::new(session); build::process_dir(session, path)?; Ok(()) } /// Process the given `.lalrpop` file. pub fn process_file>(&self, path: P) -> Result<(), Box> { let session = Rc::new(self.session.clone()); build::process_file(session, path)?; Ok(()) } } /// Process all files in the current directory, which -- unless you /// have changed it -- is typically the root of the crate being compiled. /// /// Equivalent to `Configuration::new().process_current_dir()`. pub fn process_root() -> Result<(), Box> { Configuration::new().process_current_dir() } /// Deprecated in favor of `Configuration`. Try: /// /// ```rust /// Configuration::new().force_build(true).process_current_dir() /// ``` /// /// instead. pub fn process_root_unconditionally() -> Result<(), Box> { Configuration::new().force_build(true).process_current_dir() } lalrpop-0.17.2/src/build/action.rs000064400000000000000000000351721352730432300151630ustar0000000000000000//! Code for generating action code. //! //! From the outside, action fns have one of two forms. If they take //! symbols as input, e.g. from a production like `X = Y Z => ...` //! (which takes Y and Z as input), they have this form: //! //! ``` //! fn __action17< //! 'input, // user-declared type parameters (*) //! >( //! input: &'input str, // user-declared parameters //! __0: (usize, usize, usize), // symbols being reduced, if any //! ... //! __N: (usize, Foo, usize), // each has a type (L, T, L) //! ) -> Box> //! ``` //! //! Otherwise, they have this form: //! //! ``` //! fn __action17< //! 'input, // user-declared type parameters (*) //! >( //! input: &'input str, // user-declared parameters //! __lookbehind: &usize, // value for @R -- "end of previous token" //! __lookahead: &usize, // value for @L -- "start of next token" //! ) -> Box> //! ``` //! //! * -- in this case, those "user-declared" parameters are inserted by //! the "internal tokenizer". use grammar::repr as r; use rust::RustWrite; use std::io::{self, Write}; pub fn emit_action_code(grammar: &r::Grammar, rust: &mut RustWrite) -> io::Result<()> { for (i, defn) in grammar.action_fn_defns.iter().enumerate() { rust!(rust, ""); // we always thread the parameters through to the action code, // even if they are not used, and hence we need to disable the // unused variables lint, which otherwise gets very excited. if !grammar.parameters.is_empty() { rust!(rust, "#[allow(unused_variables)]"); } match defn.kind { r::ActionFnDefnKind::User(ref data) => { emit_user_action_code(grammar, rust, i, defn, data)? } r::ActionFnDefnKind::Lookaround(ref variant) => { emit_lookaround_action_code(grammar, rust, i, defn, variant)? } r::ActionFnDefnKind::Inline(ref data) => { emit_inline_action_code(grammar, rust, i, defn, data)? } } } Ok(()) } fn ret_type_string(grammar: &r::Grammar, defn: &r::ActionFnDefn) -> String { if defn.fallible { format!( "Result<{},{}lalrpop_util::ParseError<{},{},{}>>", defn.ret_type, grammar.prefix, grammar.types.terminal_loc_type(), grammar.types.terminal_token_type(), grammar.types.error_type() ) } else { format!("{}", defn.ret_type) } } fn emit_user_action_code( grammar: &r::Grammar, rust: &mut RustWrite, index: usize, defn: &r::ActionFnDefn, data: &r::UserActionFnDefn, ) -> io::Result<()> { let ret_type = ret_type_string(grammar, defn); // For each symbol to be reduced, we will receive // a (L, T, L) triple where the Ls are locations and // the T is the data. Ignore the locations and bind // the data to the name the user gave. let mut arguments: Vec = data .arg_patterns .iter() .zip( data.arg_types .iter() .cloned() .map(|t| grammar.types.spanned_type(t)), ) .map(|(name, ty)| format!("(_, {}, _): {}", name, ty)) .collect(); // If this is a reduce of an empty production, we will // automatically add position information in the form of // lookbehind/lookahead values. Otherwise, those values would be // determined from the arguments themselves. if data.arg_patterns.is_empty() { arguments.extend(vec![ format!( "{}lookbehind: &{}", grammar.prefix, grammar.types.terminal_loc_type() ), format!( "{}lookahead: &{}", grammar.prefix, grammar.types.terminal_loc_type() ), ]); } rust.fn_header( &r::Visibility::Priv, format!("{}action{}", grammar.prefix, index), ) .with_grammar(grammar) .with_parameters(arguments) .with_return_type(ret_type) .emit()?; rust!(rust, "{{"); rust!(rust, "{}", data.code); rust!(rust, "}}"); Ok(()) } fn emit_lookaround_action_code( grammar: &r::Grammar, rust: &mut RustWrite, index: usize, _defn: &r::ActionFnDefn, data: &r::LookaroundActionFnDefn, ) -> io::Result<()> { rust.fn_header( &r::Visibility::Priv, format!("{}action{}", grammar.prefix, index), ) .with_grammar(grammar) .with_parameters(vec![ format!( "{}lookbehind: &{}", grammar.prefix, grammar.types.terminal_loc_type() ), format!( "{}lookahead: &{}", grammar.prefix, grammar.types.terminal_loc_type() ), ]) .with_return_type(format!("{}", grammar.types.terminal_loc_type())) .emit()?; rust!(rust, "{{"); match *data { r::LookaroundActionFnDefn::Lookahead => { // take the lookahead, if any; otherwise, we are // at EOF, so taker the lookbehind (end of last // pushed token); if that is missing too, then // supply default. rust!(rust, "{}lookahead.clone()", grammar.prefix); } r::LookaroundActionFnDefn::Lookbehind => { // take lookbehind or supply default rust!(rust, "{}lookbehind.clone()", grammar.prefix); } } rust!(rust, "}}"); Ok(()) } fn emit_inline_action_code( grammar: &r::Grammar, rust: &mut RustWrite, index: usize, defn: &r::ActionFnDefn, data: &r::InlineActionFnDefn, ) -> io::Result<()> { let ret_type = ret_type_string(grammar, defn); let arg_types: Vec<_> = data .symbols .iter() .flat_map(|sym| match *sym { r::InlinedSymbol::Original(ref s) => vec![s.clone()], r::InlinedSymbol::Inlined(_, ref syms) => syms.clone(), }) .map(|s| s.ty(&grammar.types)) .collect(); // this is the number of symbols we expect to be passed in; it is // distinct from data.symbols.len(), because sometimes we have // inlined actions with no input symbols let num_flat_args = arg_types.len(); let mut arguments: Vec<_> = arg_types .iter() .map(|&t| grammar.types.spanned_type(t.clone())) .enumerate() .map(|(i, t)| format!("{}{}: {}", grammar.prefix, i, t)) .collect(); // If no symbols are being reduced, add in the // lookbehind/lookahead. if arguments.is_empty() { arguments.extend(vec![ format!( "{}lookbehind: &{}", grammar.prefix, grammar.types.terminal_loc_type() ), format!( "{}lookahead: &{}", grammar.prefix, grammar.types.terminal_loc_type() ), ]); } rust.fn_header( &r::Visibility::Priv, format!("{}action{}", grammar.prefix, index), ) .with_grammar(grammar) .with_parameters(arguments) .with_return_type(ret_type) .emit()?; rust!(rust, "{{"); // For each inlined thing, compute the start/end locations. // Do this first so that none of the arguments have been moved // yet and we can easily access their locations. let mut arg_counter = 0; let mut temp_counter = 0; for symbol in &data.symbols { match *symbol { r::InlinedSymbol::Original(_) => { arg_counter += 1; } r::InlinedSymbol::Inlined(_, ref syms) => { if !syms.is_empty() { // If we are reducing symbols, then start and end // can be the start/end location of the first/last // symbol respectively. Easy peezy. rust!( rust, "let {}start{} = {}{}.0.clone();", grammar.prefix, temp_counter, grammar.prefix, arg_counter ); let last_arg_index = arg_counter + syms.len() - 1; rust!( rust, "let {}end{} = {}{}.2.clone();", grammar.prefix, temp_counter, grammar.prefix, last_arg_index ); } else { // If we have no symbols, then `arg_counter` // represents index of the first symbol after this // inlined item (if any), and `arg_counter-1` // represents index of the symbol before this // item. if arg_counter > 0 { rust!( rust, "let {}start{} = {}{}.2.clone();", grammar.prefix, temp_counter, grammar.prefix, arg_counter - 1 ); } else if num_flat_args > 0 { rust!( rust, "let {}start{} = {}{}.0.clone();", grammar.prefix, temp_counter, grammar.prefix, arg_counter ); } else { rust!( rust, "let {}start{} = {}lookbehind.clone();", grammar.prefix, temp_counter, grammar.prefix ); } if arg_counter < num_flat_args { rust!( rust, "let {}end{} = {}{}.0.clone();", grammar.prefix, temp_counter, grammar.prefix, arg_counter ); } else if num_flat_args > 0 { rust!( rust, "let {}end{} = {}{}.2.clone();", grammar.prefix, temp_counter, grammar.prefix, num_flat_args - 1 ); } else { rust!( rust, "let {}end{} = {}lookahead.clone();", grammar.prefix, temp_counter, grammar.prefix ); } } temp_counter += 1; arg_counter += syms.len(); } } } // Now create temporaries for the inlined things let mut arg_counter = 0; let mut temp_counter = 0; // if there are type parameters then type annotation is required let annotate = !grammar.non_lifetime_type_parameters().is_empty(); let lparen = if annotate { "::<" } else { "(" }; for symbol in &data.symbols { match *symbol { r::InlinedSymbol::Original(_) => { arg_counter += 1; } r::InlinedSymbol::Inlined(inlined_action, ref syms) => { // execute the inlined reduce action rust!( rust, "let {}temp{} = {}action{}{}", grammar.prefix, temp_counter, grammar.prefix, inlined_action.index(), lparen ); for t in grammar.non_lifetime_type_parameters() { rust!(rust, "{},", t); } if annotate { rust!(rust, ">("); } for parameter in &grammar.parameters { rust!(rust, "{},", parameter.name); } for i in 0..syms.len() { rust!(rust, "{}{},", grammar.prefix, arg_counter + i); } if syms.is_empty() { rust!(rust, "&{}start{},", grammar.prefix, temp_counter); rust!(rust, "&{}end{},", grammar.prefix, temp_counter); } rust!(rust, ");"); // wrap up the inlined value along with its span rust!( rust, "let {}temp{} = ({}start{}, {}temp{}, {}end{});", grammar.prefix, temp_counter, grammar.prefix, temp_counter, grammar.prefix, temp_counter, grammar.prefix, temp_counter ); temp_counter += 1; arg_counter += syms.len(); } } } rust!( rust, "{}action{}{}", grammar.prefix, data.action.index(), lparen ); for t in grammar.non_lifetime_type_parameters() { rust!(rust, "{},", t); } if annotate { rust!(rust, ">("); } for parameter in &grammar.parameters { rust!(rust, "{},", parameter.name); } let mut arg_counter = 0; let mut temp_counter = 0; for symbol in &data.symbols { match *symbol { r::InlinedSymbol::Original(_) => { rust!(rust, "{}{},", grammar.prefix, arg_counter); arg_counter += 1; } r::InlinedSymbol::Inlined(_, ref syms) => { rust!(rust, "{}temp{},", grammar.prefix, temp_counter); temp_counter += 1; arg_counter += syms.len(); } } } assert!(!data.symbols.is_empty()); rust!(rust, ")"); rust!(rust, "}}"); Ok(()) } lalrpop-0.17.2/src/build/fake_term.rs000064400000000000000000000033031346406170700156400ustar0000000000000000use std::io::{self, Write}; use term::color::Color; use term::{self, Attr, Terminal}; /// A `Terminal` that just ignores all attempts at formatting. Used /// to report errors when no ANSI terminfo is available. pub struct FakeTerminal { write: W, } impl FakeTerminal { pub fn new(write: W) -> FakeTerminal { FakeTerminal { write } } } impl Write for FakeTerminal { fn write(&mut self, buf: &[u8]) -> io::Result { self.write.write(buf) } fn flush(&mut self) -> io::Result<()> { self.write.flush() } } impl Terminal for FakeTerminal { type Output = W; fn fg(&mut self, _color: Color) -> term::Result<()> { Ok(()) } fn bg(&mut self, _color: Color) -> term::Result<()> { Ok(()) } fn attr(&mut self, _attr: Attr) -> term::Result<()> { Ok(()) } fn supports_attr(&self, _attr: Attr) -> bool { false } fn reset(&mut self) -> term::Result<()> { Ok(()) } fn supports_reset(&self) -> bool { false } fn supports_color(&self) -> bool { false } fn cursor_up(&mut self) -> term::Result<()> { Ok(()) } fn delete_line(&mut self) -> term::Result<()> { Ok(()) } fn carriage_return(&mut self) -> term::Result<()> { Ok(()) } fn get_ref(&self) -> &Self::Output { &self.write } fn get_mut(&mut self) -> &mut Self::Output { &mut self.write } fn into_inner(self) -> Self::Output where Self: Sized, { self.write } } lalrpop-0.17.2/src/build/mod.rs000064400000000000000000000427101350346013400144560ustar0000000000000000//! Utilies for running in a build script. use atty; use file_text::FileText; use grammar::parse_tree as pt; use grammar::repr as r; use lalrpop_util::ParseError; use lexer::intern_token; use lr1; use message::builder::InlineBuilder; use message::{Content, Message}; use normalize; use parser; use rust::RustWrite; use session::{ColorConfig, Session}; use sha2::{Digest, Sha256}; use term; use tls::Tls; use tok; use std::fs; use std::io::{self, BufRead, Write}; use std::path::{Path, PathBuf}; use std::process::exit; use std::rc::Rc; mod action; mod fake_term; use self::fake_term::FakeTerminal; const LALRPOP_VERSION_HEADER: &str = concat!( "// auto-generated: \"", env!("CARGO_PKG_NAME"), " ", env!("CARGO_PKG_VERSION"), "\"" ); fn hash_file(file: &Path) -> io::Result { let mut file = fs::File::open(&file)?; let mut sha_256 = Sha256::new(); io::copy(&mut file, &mut sha_256)?; let mut hash_str = "// sha256: ".to_owned(); for byte in sha_256.result() { hash_str.push_str(&format!("{:x}", byte)); } Ok(hash_str) } pub fn process_dir>(session: Rc, root_dir: P) -> io::Result<()> { let lalrpop_files = lalrpop_files(root_dir)?; for lalrpop_file in lalrpop_files { process_file(session.clone(), lalrpop_file)?; } Ok(()) } pub fn process_file>(session: Rc, lalrpop_file: P) -> io::Result<()> { let lalrpop_file = lalrpop_file.as_ref(); let rs_file = resolve_rs_file(&session, lalrpop_file)?; let report_file = resolve_report_file(&session, lalrpop_file)?; process_file_into(session, lalrpop_file, &rs_file, &report_file) } fn resolve_rs_file(session: &Session, lalrpop_file: &Path) -> io::Result { gen_resolve_file(session, lalrpop_file, "rs") } fn resolve_report_file(session: &Session, lalrpop_file: &Path) -> io::Result { gen_resolve_file(session, lalrpop_file, "report") } fn gen_resolve_file(session: &Session, lalrpop_file: &Path, ext: &str) -> io::Result { let in_dir = if let Some(ref d) = session.in_dir { d.as_path() } else { Path::new(".") }; let out_dir = if let Some(ref d) = session.out_dir { d.as_path() } else { in_dir }; // If the lalrpop file is not in in_dir, the result is that the // .rs file is created in the same directory as the lalrpop file // for compatibility reasons Ok(out_dir .join(lalrpop_file.strip_prefix(&in_dir).unwrap_or(lalrpop_file)) .with_extension(ext)) } fn process_file_into( session: Rc, lalrpop_file: &Path, rs_file: &Path, report_file: &Path, ) -> io::Result<()> { session.emit_rerun_directive(lalrpop_file); if session.force_build || needs_rebuild(&lalrpop_file, &rs_file)? { log!( session, Informative, "processing file `{}`", lalrpop_file.to_string_lossy() ); if let Some(parent) = rs_file.parent() { fs::create_dir_all(parent)?; } remove_old_file(&rs_file)?; // Load the LALRPOP source text for this file: let file_text = Rc::new(FileText::from_path(lalrpop_file.to_path_buf())?); // Store the session and file-text in TLS -- this is not // intended to be used in this high-level code, but it gives // easy access to this information pervasively in the // low-level LR(1) and grammar normalization code. This is // particularly useful for error-reporting. let _tls = Tls::install(session.clone(), file_text.clone()); // Do the LALRPOP processing itself and write the resulting // buffer into a file. We use a buffer so that if LR(1) // generation fails at some point, we don't leave a partial // file behind. { let grammar = parse_and_normalize_grammar(&session, &file_text)?; let buffer = emit_recursive_ascent(&session, &grammar, &report_file)?; let mut output_file = fs::File::create(&rs_file)?; writeln!(output_file, "{}", LALRPOP_VERSION_HEADER)?; writeln!(output_file, "{}", hash_file(&lalrpop_file)?)?; output_file.write_all(&buffer)?; } } Ok(()) } fn remove_old_file(rs_file: &Path) -> io::Result<()> { match fs::remove_file(rs_file) { Ok(()) => Ok(()), Err(e) => { // Unix reports NotFound, Windows PermissionDenied! match e.kind() { io::ErrorKind::NotFound | io::ErrorKind::PermissionDenied => Ok(()), _ => Err(e), } } } } fn needs_rebuild(lalrpop_file: &Path, rs_file: &Path) -> io::Result { match fs::File::open(&rs_file) { Ok(rs_file) => { let mut version_str = String::new(); let mut hash_str = String::new(); let mut f = io::BufReader::new(rs_file); f.read_line(&mut version_str)?; f.read_line(&mut hash_str)?; Ok(hash_str.trim() != hash_file(&lalrpop_file)? || version_str.trim() != LALRPOP_VERSION_HEADER) } Err(e) => match e.kind() { io::ErrorKind::NotFound => Ok(true), _ => Err(e), }, } } fn lalrpop_files>(root_dir: P) -> io::Result> { let mut result = vec![]; for entry in fs::read_dir(root_dir)? { let entry = entry?; let file_type = entry.file_type()?; let path = entry.path(); if file_type.is_dir() { result.extend(lalrpop_files(&path)?); } if file_type.is_file() && path.extension().is_some() && path.extension().unwrap() == "lalrpop" { result.push(path); } } Ok(result) } fn parse_and_normalize_grammar(session: &Session, file_text: &FileText) -> io::Result { let grammar = match parser::parse_grammar(file_text.text()) { Ok(grammar) => grammar, Err(ParseError::InvalidToken { location }) => { let ch = file_text.text()[location..].chars().next().unwrap(); report_error( &file_text, pt::Span(location, location), &format!("invalid character `{}`", ch), ); } Err(ParseError::UnrecognizedEOF { location, .. }) => { report_error( &file_text, pt::Span(location, location), "unexpected end of file", ); } Err(ParseError::UnrecognizedToken { token: (lo, _, hi), expected, }) => { let _ = expected; // didn't implement this yet :) let text = &file_text.text()[lo..hi]; report_error( &file_text, pt::Span(lo, hi), &format!("unexpected token: `{}`", text), ); } Err(ParseError::ExtraToken { token: (lo, _, hi) }) => { let text = &file_text.text()[lo..hi]; report_error( &file_text, pt::Span(lo, hi), &format!("extra token at end of input: `{}`", text), ); } Err(ParseError::User { error }) => { let string = match error.code { tok::ErrorCode::UnrecognizedToken => "unrecognized token", tok::ErrorCode::UnterminatedEscape => "unterminated escape; missing '`'?", tok::ErrorCode::UnrecognizedEscape => { "unrecognized escape; only \\n, \\r, \\t, \\\" and \\\\ are recognized" } tok::ErrorCode::UnterminatedStringLiteral => { "unterminated string literal; missing `\"`?" } tok::ErrorCode::UnterminatedCharacterLiteral => { "unterminated character literal; missing `'`?" } tok::ErrorCode::UnterminatedAttribute => "unterminated #! attribute; missing `]`?", tok::ErrorCode::ExpectedStringLiteral => "expected string literal; missing `\"`?", tok::ErrorCode::UnterminatedCode => { "unterminated code block; perhaps a missing `;`, `)`, `]` or `}`?" } }; report_error( &file_text, pt::Span(error.location, error.location + 1), string, ) } }; match normalize::normalize(session, grammar) { Ok(grammar) => Ok(grammar), Err(error) => report_error(&file_text, error.span, &error.message), } } fn report_error(file_text: &FileText, span: pt::Span, message: &str) -> ! { println!("{} error: {}", file_text.span_str(span), message); let out = io::stderr(); let mut out = out.lock(); file_text.highlight(span, &mut out).unwrap(); exit(1); } fn report_messages(messages: Vec) -> term::Result<()> { let builder = InlineBuilder::new().begin_paragraphs(); let builder = messages .into_iter() .fold(builder, |b, m| b.push(Box::new(m))); let content = builder.end().end(); report_content(&*content) } fn report_content(content: &dyn Content) -> term::Result<()> { // FIXME -- can we query the size of the terminal somehow? let canvas = content.emit_to_canvas(80); let try_colors = match Tls::session().color_config { ColorConfig::Yes => true, ColorConfig::No => false, ColorConfig::IfTty => atty::is(atty::Stream::Stdout), }; if try_colors { if let Some(mut stdout) = term::stdout() { return canvas.write_to(&mut *stdout); } } let stdout = io::stdout(); let mut stdout = FakeTerminal::new(stdout.lock()); canvas.write_to(&mut stdout) } fn emit_module_attributes( grammar: &r::Grammar, rust: &mut RustWrite, ) -> io::Result<()> { rust.write_module_attributes(grammar) } fn emit_uses(grammar: &r::Grammar, rust: &mut RustWrite) -> io::Result<()> { rust.write_uses("", grammar) } fn emit_recursive_ascent( session: &Session, grammar: &r::Grammar, report_file: &Path, ) -> io::Result> { let mut rust = RustWrite::new(vec![]); // We generate a module structure like this: // // ``` // mod { // // For each public symbol: // pub fn parse_XYZ(); // mod __XYZ { ... } // // // For each bit of action code: // // } // ``` // // Note that the action code goes in the outer module. This is // intentional because it means that the foo.lalrpop file serves // as a module in the rust hierarchy, so if the action code // includes things like `super::` it will resolve in the natural // way. emit_module_attributes(grammar, &mut rust)?; emit_uses(grammar, &mut rust)?; if grammar.start_nonterminals.is_empty() { println!("Error: no public symbols declared in grammar"); exit(1); } for (user_nt, start_nt) in &grammar.start_nonterminals { // We generate these, so there should always be exactly 1 // production. Otherwise the LR(1) algorithm doesn't know // where to stop! assert_eq!(grammar.productions_for(start_nt).len(), 1); log!( session, Verbose, "Building states for public nonterminal `{}`", user_nt ); let _lr1_tls = lr1::Lr1Tls::install(grammar.terminals.clone()); let lr1result = lr1::build_states(&grammar, start_nt.clone()); if session.emit_report { let mut output_report_file = fs::File::create(&report_file)?; lr1::generate_report(&mut output_report_file, &lr1result)?; } let states = match lr1result { Ok(states) => states, Err(error) => { let messages = lr1::report_error(&grammar, &error); let _ = report_messages(messages); exit(1) // FIXME -- propagate up instead of calling `exit` } }; match grammar.algorithm.codegen { r::LrCodeGeneration::RecursiveAscent => lr1::codegen::ascent::compile( &grammar, user_nt.clone(), start_nt.clone(), &states, "super", &mut rust, )?, r::LrCodeGeneration::TableDriven => lr1::codegen::parse_table::compile( &grammar, user_nt.clone(), start_nt.clone(), &states, "super", &mut rust, )?, r::LrCodeGeneration::TestAll => lr1::codegen::test_all::compile( &grammar, user_nt.clone(), start_nt.clone(), &states, &mut rust, )?, } rust!( rust, "{}use self::{}parse{}::{}Parser;", grammar.nonterminals[&user_nt].visibility, grammar.prefix, start_nt, user_nt ); } if let Some(ref intern_token) = grammar.intern_token { intern_token::compile(&grammar, intern_token, &mut rust)?; rust!(rust, "pub use self::{}intern_token::Token;", grammar.prefix); } action::emit_action_code(grammar, &mut rust)?; emit_to_triple_trait(grammar, &mut rust)?; Ok(rust.into_inner()) } fn emit_to_triple_trait(grammar: &r::Grammar, rust: &mut RustWrite) -> io::Result<()> { #![allow(non_snake_case)] let L = grammar.types.terminal_loc_type(); let T = grammar.types.terminal_token_type(); let E = grammar.types.error_type(); let parse_error = format!( "{p}lalrpop_util::ParseError<{L}, {T}, {E}>", p = grammar.prefix, L = L, T = T, E = E, ); let mut user_type_parameters = String::new(); for type_parameter in &grammar.type_parameters { user_type_parameters.push_str(&format!("{}, ", type_parameter)); } rust!(rust, ""); rust!( rust, "pub trait {}ToTriple<{}> {{", grammar.prefix, user_type_parameters, ); rust!( rust, "fn to_triple(value: Self) -> Result<({L},{T},{L}), {parse_error}>;", L = L, T = T, parse_error = parse_error, ); rust!(rust, "}}"); rust!(rust, ""); if grammar.types.opt_terminal_loc_type().is_some() { rust!( rust, "impl<{utp}> {p}ToTriple<{utp}> for ({L}, {T}, {L}) {{", p = grammar.prefix, utp = user_type_parameters, L = L, T = T, ); rust!( rust, "fn to_triple(value: Self) -> Result<({L},{T},{L}), {parse_error}> {{", L = L, T = T, parse_error = parse_error, ); rust!(rust, "Ok(value)"); rust!(rust, "}}"); rust!(rust, "}}"); rust!( rust, "impl<{utp}> {p}ToTriple<{utp}> for Result<({L}, {T}, {L}), {E}> {{", utp = user_type_parameters, p = grammar.prefix, L = L, T = T, E = E, ); rust!( rust, "fn to_triple(value: Self) -> Result<({L},{T},{L}), {parse_error}> {{", L = L, T = T, parse_error = parse_error, ); rust!(rust, "match value {{"); rust!(rust, "Ok(v) => Ok(v),"); rust!( rust, "Err(error) => Err({p}lalrpop_util::ParseError::User {{ error }}),", p = grammar.prefix ); rust!(rust, "}}"); // match rust!(rust, "}}"); rust!(rust, "}}"); } else { rust!( rust, "impl<{utp}> {p}ToTriple<{utp}> for {T} {{", utp = user_type_parameters, p = grammar.prefix, T = T, ); rust!( rust, "fn to_triple(value: Self) -> Result<((),{T},()), {parse_error}> {{", T = T, parse_error = parse_error, ); rust!(rust, "Ok(((), value, ()))"); rust!(rust, "}}"); rust!(rust, "}}"); rust!( rust, "impl<{utp}> {p}ToTriple<{utp}> for Result<({T}),{E}> {{", utp = user_type_parameters, p = grammar.prefix, T = T, E = E, ); rust!( rust, "fn to_triple(value: Self) -> Result<((),{T},()), {parse_error}> {{", T = T, parse_error = parse_error, ); rust!(rust, "match value {{"); rust!(rust, "Ok(v) => Ok(((), v, ())),"); rust!( rust, "Err(error) => Err({p}lalrpop_util::ParseError::User {{ error }}),", p = grammar.prefix ); rust!(rust, "}}"); // match rust!(rust, "}}"); // fn rust!(rust, "}}"); // impl } Ok(()) } lalrpop-0.17.2/src/collections/map.rs000064400000000000000000000011121341573331700156720ustar0000000000000000use std::collections::BTreeMap; pub use std::collections::btree_map::Entry; /// In general, we avoid coding directly against any particular map, /// but rather build against `util::Map` (and `util::map` to construct /// an instance). This should be a deterministic map, such that two /// runs of LALRPOP produce the same output, but otherwise it doesn't /// matter much. I'd probably prefer to use `HashMap` with an /// alternative hasher, but that's not stable. pub type Map = BTreeMap; pub fn map() -> Map { Map::::default() } lalrpop-0.17.2/src/collections/mod.rs000064400000000000000000000002351341573331700157010ustar0000000000000000mod map; mod multimap; mod set; pub use self::map::{map, Entry, Map}; pub use self::multimap::{Collection, Multimap}; pub use self::set::{set, Set}; lalrpop-0.17.2/src/collections/multimap.rs000064400000000000000000000064521341573331700167610ustar0000000000000000use std::collections::btree_map; use std::default::Default; use std::iter::FromIterator; use super::map::{map, Map}; use super::set::Set; pub struct Multimap { map: Map, } pub trait Collection: Default { type Item; /// Push `item` into the collection and return `true` if /// collection changed. fn push(&mut self, item: Self::Item) -> bool; } impl Multimap { pub fn new() -> Multimap { Multimap { map: map() } } pub fn is_empty(&self) -> bool { self.map.is_empty() } /// Push `value` to the collection associated with `key`. Returns /// true if the collection was changed from the default. pub fn push(&mut self, key: K, value: C::Item) -> bool { let mut inserted = false; let pushed = self .map .entry(key) .or_insert_with(|| { inserted = true; C::default() }) .push(value); inserted || pushed } pub fn get(&self, key: &K) -> Option<&C> { self.map.get(key) } pub fn iter(&self) -> btree_map::Iter { self.map.iter() } pub fn into_iter(self) -> btree_map::IntoIter { self.map.into_iter() } } impl IntoIterator for Multimap { type Item = (K, C); type IntoIter = btree_map::IntoIter; fn into_iter(self) -> btree_map::IntoIter { self.into_iter() } } impl<'iter, K: Ord, C: Collection> IntoIterator for &'iter Multimap { type Item = (&'iter K, &'iter C); type IntoIter = btree_map::Iter<'iter, K, C>; fn into_iter(self) -> btree_map::Iter<'iter, K, C> { self.iter() } } impl FromIterator<(K, C::Item)> for Multimap { fn from_iter(iterator: T) -> Self where T: IntoIterator, { let mut map = Multimap::new(); for (key, value) in iterator { map.push(key, value); } map } } impl Collection for () { type Item = (); fn push(&mut self, _item: ()) -> bool { false } } impl Collection for Vec { type Item = T; fn push(&mut self, item: T) -> bool { self.push(item); true // always changes } } impl Collection for Set { type Item = T; fn push(&mut self, item: T) -> bool { self.insert(item) } } impl Default for Multimap { fn default() -> Self { Multimap::new() } } impl, I> Collection for Multimap { type Item = (K, I); fn push(&mut self, item: (K, I)) -> bool { let (key, value) = item; self.push(key, value) } } #[test] fn push() { let mut m: Multimap> = Multimap::new(); assert!(m.push(0, 'a')); assert!(m.push(0, 'b')); assert!(!m.push(0, 'b')); assert!(m.push(1, 'a')); } #[test] fn push_nil() { let mut m: Multimap = Multimap::new(); assert!(m.push(0, ())); assert!(!m.push(0, ())); assert!(m.push(1, ())); assert!(!m.push(0, ())); } lalrpop-0.17.2/src/collections/set.rs000064400000000000000000000002401326645251200157100ustar0000000000000000use std::collections::BTreeSet; /// As `Map`, but for sets. pub type Set = BTreeSet; pub fn set() -> Set { Set::::default() } lalrpop-0.17.2/src/file_text.rs000064400000000000000000000106431350346013400145630ustar0000000000000000use grammar::parse_tree as pt; use std::fmt::{Display, Error, Formatter}; use std::fs::File; use std::io::{self, Read, Write}; use std::path::PathBuf; pub struct FileText { path: PathBuf, input_str: String, newlines: Vec, } impl FileText { pub fn from_path(path: PathBuf) -> io::Result { let mut input_str = String::new(); let mut f = File::open(&path)?; f.read_to_string(&mut input_str)?; Ok(FileText::new(path, input_str)) } pub fn new(path: PathBuf, input_str: String) -> FileText { let newline_indices: Vec = { let input_indices = input_str .as_bytes() .iter() .enumerate() .filter(|&(_, &b)| b == b'\n') .map(|(i, _)| i + 1); // index of first char in the line Some(0).into_iter().chain(input_indices).collect() }; FileText { path, input_str, newlines: newline_indices, } } #[cfg(test)] pub fn test() -> FileText { Self::new(PathBuf::from("test.lalrpop"), String::from("")) } pub fn text(&self) -> &String { &self.input_str } pub fn span_str(&self, span: pt::Span) -> String { let (start_line, start_col) = self.line_col(span.0); let (end_line, end_col) = self.line_col(span.1); format!( "{}:{}:{}: {}:{}", self.path.display(), start_line + 1, start_col + 1, end_line + 1, end_col ) } fn line_col(&self, pos: usize) -> (usize, usize) { let num_lines = self.newlines.len(); let line = (0..num_lines) .filter(|&i| self.newlines[i] > pos) .map(|i| i - 1) .next() .unwrap_or(num_lines - 1); // offset of the first character in `line` let line_offset = self.newlines[line]; // find the column; use `saturating_sub` in case `pos` is the // newline itself, which we'll call column 0 let col = pos - line_offset; (line, col) } fn line_text(&self, line_num: usize) -> &str { let start_offset = self.newlines[line_num]; if line_num == self.newlines.len() - 1 { &self.input_str[start_offset..] } else { let end_offset = self.newlines[line_num + 1]; &self.input_str[start_offset..end_offset - 1] } } pub fn highlight(&self, span: pt::Span, out: &mut dyn Write) -> io::Result<()> { let (start_line, start_col) = self.line_col(span.0); let (end_line, end_col) = self.line_col(span.1); // (*) use `saturating_sub` since the start line could be the newline // itself, in which case we'll call it column zero // span is within one line: if start_line == end_line { let text = self.line_text(start_line); writeln!(out, " {}", text)?; if end_col - start_col <= 1 { writeln!(out, " {}^", Repeat(' ', start_col))?; } else { let width = end_col - start_col; writeln!( out, " {}~{}~", Repeat(' ', start_col), Repeat('~', width.saturating_sub(2)) )?; } } else { // span is across many lines, find the maximal width of any of those let line_strs: Vec<_> = (start_line..=end_line).map(|i| self.line_text(i)).collect(); let max_len = line_strs.iter().map(|l| l.len()).max().unwrap(); writeln!( out, " {}{}~+", Repeat(' ', start_col), Repeat('~', max_len - start_col) )?; for line in &line_strs[..line_strs.len() - 1] { writeln!(out, "| {0:<1$} |", line, max_len)?; } writeln!(out, "| {}", line_strs[line_strs.len() - 1])?; writeln!(out, "+~{}", Repeat('~', end_col))?; } Ok(()) } } struct Repeat(char, usize); impl Display for Repeat { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { for _ in 0..self.1 { write!(fmt, "{}", self.0)?; } Ok(()) } } lalrpop-0.17.2/src/generate.rs000064400000000000000000000043241346406170700144020ustar0000000000000000//! Generate valid parse trees. use grammar::repr::*; use rand::{self, Rng}; use std::iter::Iterator; #[derive(PartialEq, Eq)] pub enum ParseTree { Nonterminal(NonterminalString, Vec), Terminal(TerminalString), } pub fn random_parse_tree(grammar: &Grammar, symbol: NonterminalString) -> ParseTree { let mut gen = Generator { grammar, rng: rand::thread_rng(), depth: 0, }; loop { // sometimes, the random walk overflows the stack, so we have a max, and if // it is exceeded, we just try again if let Some(result) = gen.nonterminal(symbol.clone()) { return result; } gen.depth = 0; } } struct Generator<'grammar> { grammar: &'grammar Grammar, rng: rand::rngs::ThreadRng, depth: u32, } const MAX_DEPTH: u32 = 10000; impl<'grammar> Generator<'grammar> { fn nonterminal(&mut self, nt: NonterminalString) -> Option { if self.depth > MAX_DEPTH { return None; } self.depth += 1; let productions = self.grammar.productions_for(&nt); let index: usize = self.rng.gen_range(0, productions.len()); let production = &productions[index]; let trees: Option> = production .symbols .iter() .map(|sym| self.symbol(sym.clone())) .collect(); trees.map(|trees| ParseTree::Nonterminal(nt, trees)) } fn symbol(&mut self, symbol: Symbol) -> Option { match symbol { Symbol::Nonterminal(nt) => self.nonterminal(nt), Symbol::Terminal(t) => Some(ParseTree::Terminal(t)), } } } impl ParseTree { pub fn terminals(&self) -> Vec { let mut vec = vec![]; self.push_terminals(&mut vec); vec } fn push_terminals(&self, vec: &mut Vec) { match *self { ParseTree::Terminal(ref s) => vec.push(s.clone()), ParseTree::Nonterminal(_, ref trees) => { for tree in trees { tree.push_terminals(vec); } } } } } lalrpop-0.17.2/src/grammar/consts.rs000064400000000000000000000017511346406170700155500ustar0000000000000000/// Recognized associated type for the token location pub const LOCATION: &str = "Location"; /// Recognized associated type for custom errors pub const ERROR: &str = "Error"; /// The lifetime parameter injected when we do not have an external token enum pub const INPUT_LIFETIME: &str = "'input"; /// The parameter injected when we do not have an external token enum pub const INPUT_PARAMETER: &str = "input"; /// The annotation to request inlining. pub const INLINE: &str = "inline"; /// The annotation to request conditional compilation. pub const CFG: &str = "cfg"; /// Annotation to request LALR. pub const LALR: &str = "LALR"; /// Annotation to request recursive-ascent-style code generation. pub const TABLE_DRIVEN: &str = "table_driven"; /// Annotation to request recursive-ascent-style code generation. pub const RECURSIVE_ASCENT: &str = "recursive_ascent"; /// Annotation to request test-all-style code generation. pub const TEST_ALL: &str = "test_all"; lalrpop-0.17.2/src/grammar/free_variables/mod.rs000064400000000000000000000157661352730432300177740ustar0000000000000000use grammar::parse_tree::{self, Lifetime, TypeParameter}; use grammar::repr; use std::iter; use string_cache::DefaultAtom as Atom; mod test; /// Finds the set of "free variables" in something -- that is, the /// type/lifetime parameters that appear and are not bound. For /// example, `T: Foo` would return `[T, U]`. pub trait FreeVariables { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec; } /// Subtle: the free-variables code sometimes encounter ambiguous /// names. For example, we might see `Vec` -- in that case, we /// look at the list of declared type parameters to decide whether /// `Foo` is a type parameter or just some other type name. fn free_type(type_parameters: &[TypeParameter], id: &Atom) -> Vec { let tp = TypeParameter::Id(id.clone()); if type_parameters.contains(&tp) { vec![tp] } else { vec![] } } /// Same as above: really, the only lifetime where this is relevant is /// `'static`, but it doesn't hurt to be careful. fn free_lifetime(type_parameters: &[TypeParameter], lt: &Lifetime) -> Vec { let tp = TypeParameter::Lifetime(lt.clone()); if type_parameters.contains(&tp) { vec![tp] } else { vec![] } } impl FreeVariables for Option { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec { match self { None => vec![], Some(t) => t.free_variables(type_parameters), } } } impl FreeVariables for Vec { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec { self.iter() .flat_map(|e| e.free_variables(type_parameters)) .collect() } } impl FreeVariables for repr::TypeRepr { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec { match self { repr::TypeRepr::Tuple(tys) => tys.free_variables(type_parameters), repr::TypeRepr::Nominal(data) | repr::TypeRepr::TraitObject(data) => { data.free_variables(type_parameters) } repr::TypeRepr::Associated { type_parameter, .. } => { free_type(type_parameters, type_parameter) } repr::TypeRepr::Lifetime(l) => free_lifetime(type_parameters, l), repr::TypeRepr::Ref { lifetime, referent, .. } => lifetime .iter() .map(|id| TypeParameter::Lifetime(id.clone())) .chain(referent.free_variables(type_parameters)) .collect(), repr::TypeRepr::Fn { forall, path, parameters, ret, } => path .free_variables(type_parameters) .into_iter() .chain( parameters .iter() .flat_map(|param| param.free_variables(type_parameters)), ) .chain( ret.iter() .flat_map(|ret| ret.free_variables(type_parameters)), ) .filter(|tp| !forall.contains(tp)) .collect(), } } } impl FreeVariables for repr::WhereClause { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec { match self { repr::WhereClause::Forall { binder, clause } => clause .free_variables(type_parameters) .into_iter() .filter(|tp| !binder.contains(tp)) .collect(), repr::WhereClause::Bound { subject, bound } => subject .free_variables(type_parameters) .into_iter() .chain(bound.free_variables(type_parameters)) .collect(), } } } impl FreeVariables for parse_tree::Path { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec { // A path like `foo::Bar` is considered no free variables; a // single identifier like `T` is a free variable `T`. Note // that we can't distinguish type parameters from random names // like `String`. match self.as_id() { Some(id) => free_type(type_parameters, &id), None => vec![], } } } impl FreeVariables for repr::NominalTypeRepr { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec { let repr::NominalTypeRepr { path, types } = self; path.free_variables(type_parameters) .into_iter() .chain(types.free_variables(type_parameters)) .collect() } } impl FreeVariables for parse_tree::WhereClause { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec { match self { parse_tree::WhereClause::Lifetime { lifetime, bounds } => { iter::once(TypeParameter::Lifetime(lifetime.clone())) .chain(bounds.iter().map(|l| TypeParameter::Lifetime(l.clone()))) .collect() } parse_tree::WhereClause::Type { forall, ty, bounds } => ty .free_variables(type_parameters) .into_iter() .chain(bounds.free_variables(type_parameters)) .filter(|tp| !forall.contains(tp)) .collect(), } } } impl FreeVariables for parse_tree::TypeBoundParameter { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec { match self { parse_tree::TypeBoundParameter::Lifetime(l) => free_lifetime(type_parameters, l), parse_tree::TypeBoundParameter::TypeParameter(t) => t.free_variables(type_parameters), parse_tree::TypeBoundParameter::Associated(..) => vec![], } } } impl FreeVariables for parse_tree::TypeBound { fn free_variables(&self, type_parameters: &[TypeParameter]) -> Vec { match self { parse_tree::TypeBound::Lifetime(l) => free_lifetime(type_parameters, l), parse_tree::TypeBound::Fn { forall, parameters, ret, .. } => parameters .free_variables(type_parameters) .into_iter() .chain(ret.free_variables(type_parameters)) .filter(|tp| !forall.contains(tp)) .collect(), parse_tree::TypeBound::Trait { forall, parameters, .. } => parameters .free_variables(type_parameters) .into_iter() .filter(|tp| !forall.contains(tp)) .collect(), } } } lalrpop-0.17.2/src/grammar/free_variables/test.rs000064400000000000000000000013651346406170700201700ustar0000000000000000#![cfg(test)] use grammar::free_variables::FreeVariables; use test_util::{expect_debug, normalized_grammar}; use tls::Tls; #[test] fn other_names() { // Check that `Foo` does not end up in the list of free variables. let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar<'a, T>(x: &'a mut Foo, y: Vec); pub Foo: () = (); "#, ); let p0 = &grammar.parameters[0]; expect_debug( p0.ty.free_variables(&grammar.type_parameters), "[ Lifetime( 'a ) ]", ); let p1 = &grammar.parameters[1]; expect_debug( p1.ty.free_variables(&grammar.type_parameters), "[ Id( Atom('T' type=inline) ) ]", ); } lalrpop-0.17.2/src/grammar/mod.rs000064400000000000000000000002221346225060300147770ustar0000000000000000//! The grammar definition. pub mod consts; pub mod free_variables; pub mod parse_tree; pub mod pattern; pub mod repr; // pub mod token; lalrpop-0.17.2/src/grammar/parse_tree.rs000064400000000000000000001012441352730432300163600ustar0000000000000000//! The "parse-tree" is what is produced by the parser. We use it do //! some pre-expansion and so forth before creating the proper AST. use grammar::consts::{INPUT_LIFETIME, LALR, RECURSIVE_ASCENT, TABLE_DRIVEN, TEST_ALL}; use grammar::pattern::Pattern; use grammar::repr::{self as r, NominalTypeRepr, TypeRepr}; use lexer::dfa::DFA; use message::builder::InlineBuilder; use message::Content; use std::fmt::{Debug, Display, Error, Formatter}; use string_cache::DefaultAtom as Atom; use tls::Tls; use util::Sep; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Grammar { // see field `prefix` in `grammar::repr::Grammar` pub prefix: String, pub span: Span, pub type_parameters: Vec, pub parameters: Vec, pub where_clauses: Vec>, pub items: Vec, pub annotations: Vec, pub module_attributes: Vec, } #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct Span(pub usize, pub usize); impl Into> for Span { fn into(self) -> Box { let file_text = Tls::file_text(); let string = file_text.span_str(self); // Insert an Adjacent block to prevent wrapping inside this // string: InlineBuilder::new() .begin_adjacent() .text(string) .end() .end() } } #[derive(Clone, Debug, PartialEq, Eq)] pub enum GrammarItem { MatchToken(MatchToken), ExternToken(ExternToken), InternToken(InternToken), Nonterminal(NonterminalData), Use(String), } #[derive(Clone, Debug, PartialEq, Eq)] pub struct MatchToken { pub contents: Vec, pub span: Span, } impl MatchToken { pub fn new(contents: MatchContents, span: Span) -> MatchToken { MatchToken { contents: vec![contents], span, } } // Not really sure if this is the best way to do it pub fn add(self, contents: MatchContents) -> MatchToken { let mut new_contents = self.contents.clone(); new_contents.push(contents); MatchToken { contents: new_contents, span: self.span, } } } #[derive(Clone, Debug, PartialEq, Eq)] pub struct MatchContents { pub items: Vec, } // FIXME: Validate that MatchSymbol is actually a TerminalString::Literal // and that MatchMapping is an Id or String #[derive(Clone, Debug, PartialEq, Eq)] pub enum MatchItem { CatchAll(Span), Unmapped(MatchSymbol, Span), Mapped(MatchSymbol, MatchMapping, Span), } impl MatchItem { pub fn is_catch_all(&self) -> bool { match *self { MatchItem::CatchAll(_) => true, _ => false, } } pub fn span(&self) -> Span { match *self { MatchItem::CatchAll(span) => span, MatchItem::Unmapped(_, span) => span, MatchItem::Mapped(_, _, span) => span, } } } pub type MatchSymbol = TerminalLiteral; pub type MatchMapping = TerminalString; /// Intern tokens are not typed by the user: they are synthesized in /// the absence of an "extern" declaration with information about the /// string literals etc that appear in the grammar. #[derive(Clone, Debug, PartialEq, Eq)] pub struct InternToken { /// Set of `r"foo"` and `"foo"` literals extracted from the /// grammar. Sorted by order of increasing precedence. pub match_entries: Vec, pub dfa: DFA, } /// In `token_check`, as we prepare to generate a tokenizer, we /// combine any `match` declaration the user may have given with the /// set of literals (e.g. `"foo"` or `r"[a-z]"`) that appear elsewhere /// in their in the grammar to produce a series of `MatchEntry`. Each /// `MatchEntry` roughly corresponds to one line in a `match` declaration. /// /// So e.g. if you had /// /// ``` /// match { /// r"(?i)BEGIN" => "BEGIN", /// "+" => "+", /// } else { /// _ /// } /// /// ID = r"[a-zA-Z]+" /// ``` /// /// This would correspond to three match entries: /// - `MatchEntry { match_literal: r"(?i)BEGIN", user_name: "BEGIN", precedence: 2 }` /// - `MatchEntry { match_literal: "+", user_name: "+", precedence: 3 }` /// - `MatchEntry { match_literal: "r[a-zA-Z]+"", user_name: r"[a-zA-Z]+", precedence: 0 }` /// /// A couple of things to note: /// /// - Literals appearing in the grammar are converting into an "identity" mapping /// - Each match group G is combined with the implicit priority IP of 1 for literals and 0 for /// regex to yield the final precedence; the formula is `G*2 + IP`. #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub struct MatchEntry { /// The precedence of this match entry. /// /// NB: This field must go first, so that `PartialOrd` sorts by precedence first! pub precedence: usize, pub match_literal: TerminalLiteral, pub user_name: TerminalString, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct ExternToken { pub span: Span, pub associated_types: Vec, pub enum_token: Option, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct AssociatedType { pub type_span: Span, pub type_name: Atom, pub type_ref: TypeRef, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct EnumToken { pub type_name: TypeRef, pub type_span: Span, pub conversions: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Conversion { pub span: Span, pub from: TerminalString, pub to: Pattern, } #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub struct Path { pub absolute: bool, pub ids: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum TypeRef { // (T1, T2) Tuple(Vec), // Foo<'a, 'b, T1, T2>, Foo::Bar, etc Nominal { path: Path, types: Vec, }, Ref { lifetime: Option, mutable: bool, referent: Box, }, // `dyn Trait` TraitObject { path: Path, types: Vec, }, // 'x ==> only should appear within nominal types, but what do we care Lifetime(Lifetime), // Foo or Bar ==> treated specially since macros may care Id(Atom), // ==> type of a nonterminal, emitted by macro expansion OfSymbol(SymbolKind), Fn { forall: Vec, path: Path, parameters: Vec, ret: Option>, }, } #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum WhereClause { // 'a: 'b + 'c Lifetime { lifetime: Lifetime, bounds: Vec, }, // where for<'a> &'a T: Debug + Into Type { forall: Vec, ty: T, bounds: Vec>, }, } #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum TypeBound { // The `'a` in `T: 'a`. Lifetime(Lifetime), // `for<'a> FnMut(&'a usize)` Fn { forall: Vec, path: Path, parameters: Vec, ret: Option, }, // `some::Trait` or `some::Trait` or `some::Trait` // or `for<'a> Trait<'a, T>` Trait { forall: Vec, path: Path, parameters: Vec>, }, } impl TypeBound { pub fn map(&self, mut f: F) -> TypeBound where F: FnMut(&T) -> U, { match *self { TypeBound::Lifetime(ref l) => TypeBound::Lifetime(l.clone()), TypeBound::Fn { ref forall, ref path, ref parameters, ref ret, } => TypeBound::Fn { forall: forall.clone(), path: path.clone(), parameters: parameters.iter().map(&mut f).collect(), ret: ret.as_ref().map(f), }, TypeBound::Trait { ref forall, ref path, ref parameters, } => TypeBound::Trait { forall: forall.clone(), path: path.clone(), parameters: parameters.iter().map(|p| p.map(&mut f)).collect(), }, } } } #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum TypeBoundParameter { // 'a Lifetime(Lifetime), // `T` or `'a` TypeParameter(T), // `Item = T` Associated(Atom, T), } impl TypeBoundParameter { pub fn map(&self, mut f: F) -> TypeBoundParameter where F: FnMut(&T) -> U, { match *self { TypeBoundParameter::Lifetime(ref l) => TypeBoundParameter::Lifetime(l.clone()), TypeBoundParameter::TypeParameter(ref t) => TypeBoundParameter::TypeParameter(f(t)), TypeBoundParameter::Associated(ref id, ref t) => { TypeBoundParameter::Associated(id.clone(), f(t)) } } } } #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub enum TypeParameter { Lifetime(Lifetime), Id(Atom), } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Parameter { pub name: Atom, pub ty: TypeRef, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum Visibility { Pub(Option), Priv, } impl Visibility { pub fn is_pub(&self) -> bool { match *self { Visibility::Pub(_) => true, Visibility::Priv => false, } } } #[derive(Clone, Debug, PartialEq, Eq)] pub struct NonterminalData { pub visibility: Visibility, pub name: NonterminalString, pub annotations: Vec, pub span: Span, pub args: Vec, // macro arguments pub type_decl: Option, pub alternatives: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Annotation { pub id_span: Span, pub id: Atom, pub arg: Option<(Atom, String)>, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Alternative { pub span: Span, pub expr: ExprSymbol, // if C, only legal in macros pub condition: Option, // => { code } pub action: Option, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum ActionKind { User(String), Fallible(String), Lookahead, Lookbehind, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Condition { pub span: Span, pub lhs: NonterminalString, // X pub rhs: Atom, // "Foo" pub op: ConditionOp, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum ConditionOp { // X == "Foo", equality Equals, // X != "Foo", inequality NotEquals, // X ~~ "Foo", regexp match Match, // X !~ "Foo", regexp non-match NotMatch, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Symbol { pub span: Span, pub kind: SymbolKind, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum SymbolKind { // (X Y) Expr(ExprSymbol), // foo, before name resolution AmbiguousId(Atom), // "foo" and foo (after name resolution) Terminal(TerminalString), // foo, after name resolution Nonterminal(NonterminalString), // foo<..> Macro(MacroSymbol), // X+, X?, X* Repeat(Box), // Choose(Box), // or Name(Name, Box), // @L Lookahead, // @R Lookbehind, Error, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Name { pub mutable: bool, pub name: Atom, } #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub enum TerminalString { Literal(TerminalLiteral), Bare(Atom), Error, } impl TerminalString { pub fn as_literal(&self) -> Option { match *self { TerminalString::Literal(ref l) => Some(l.clone()), _ => None, } } pub fn display_len(&self) -> usize { match *self { TerminalString::Literal(ref x) => x.display_len(), TerminalString::Bare(ref x) => x.len(), TerminalString::Error => "error".len(), } } } #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub enum TerminalLiteral { Quoted(Atom), Regex(Atom), } impl TerminalLiteral { /// The *base precedence* is the precedence within a `match { }` /// block level. It indicates that quoted things like `"foo"` get /// precedence over regex matches. pub fn base_precedence(&self) -> usize { match *self { TerminalLiteral::Quoted(_) => 1, TerminalLiteral::Regex(_) => 0, } } pub fn display_len(&self) -> usize { match *self { TerminalLiteral::Quoted(ref x) => x.len(), TerminalLiteral::Regex(ref x) => x.len() + "####r".len(), } } } #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct NonterminalString(pub Atom); impl NonterminalString { pub fn len(&self) -> usize { self.0.len() } } impl Into> for NonterminalString { fn into(self) -> Box { let session = Tls::session(); InlineBuilder::new() .text(self) .styled(session.nonterminal_symbol) .end() } } #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct Lifetime(pub Atom); impl Lifetime { pub fn anonymous() -> Self { Lifetime(Atom::from("'_")) } pub fn is_anonymous(&self) -> bool { *self == Self::anonymous() } pub fn statik() -> Self { Lifetime(Atom::from("'static")) } pub fn input() -> Self { Lifetime(Atom::from(INPUT_LIFETIME)) } pub fn len(&self) -> usize { self.0.len() } } #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub enum RepeatOp { Star, Plus, Question, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RepeatSymbol { pub op: RepeatOp, pub symbol: Symbol, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct ExprSymbol { pub symbols: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct MacroSymbol { pub name: NonterminalString, pub args: Vec, } impl TerminalString { pub fn quoted(i: Atom) -> TerminalString { TerminalString::Literal(TerminalLiteral::Quoted(i)) } pub fn regex(i: Atom) -> TerminalString { TerminalString::Literal(TerminalLiteral::Regex(i)) } } impl Into> for TerminalString { fn into(self) -> Box { let session = Tls::session(); InlineBuilder::new() .text(self) .styled(session.terminal_symbol) .end() } } impl Grammar { pub fn extern_token(&self) -> Option<&ExternToken> { self.items .iter() .flat_map(GrammarItem::as_extern_token) .next() } pub fn enum_token(&self) -> Option<&EnumToken> { self.items .iter() .flat_map(GrammarItem::as_extern_token) .flat_map(|et| et.enum_token.as_ref()) .next() } pub fn intern_token(&self) -> Option<&InternToken> { self.items .iter() .flat_map(GrammarItem::as_intern_token) .next() } pub fn match_token(&self) -> Option<&MatchToken> { self.items .iter() .flat_map(GrammarItem::as_match_token) .next() } } impl GrammarItem { pub fn is_macro_def(&self) -> bool { match *self { GrammarItem::Nonterminal(ref d) => d.is_macro_def(), _ => false, } } pub fn as_nonterminal(&self) -> Option<&NonterminalData> { match *self { GrammarItem::Nonterminal(ref d) => Some(d), GrammarItem::Use(..) => None, GrammarItem::MatchToken(..) => None, GrammarItem::ExternToken(..) => None, GrammarItem::InternToken(..) => None, } } pub fn as_match_token(&self) -> Option<&MatchToken> { match *self { GrammarItem::Nonterminal(..) => None, GrammarItem::Use(..) => None, GrammarItem::MatchToken(ref d) => Some(d), GrammarItem::ExternToken(..) => None, GrammarItem::InternToken(..) => None, } } pub fn as_extern_token(&self) -> Option<&ExternToken> { match *self { GrammarItem::Nonterminal(..) => None, GrammarItem::Use(..) => None, GrammarItem::MatchToken(..) => None, GrammarItem::ExternToken(ref d) => Some(d), GrammarItem::InternToken(..) => None, } } pub fn as_intern_token(&self) -> Option<&InternToken> { match *self { GrammarItem::Nonterminal(..) => None, GrammarItem::Use(..) => None, GrammarItem::MatchToken(..) => None, GrammarItem::ExternToken(..) => None, GrammarItem::InternToken(ref d) => Some(d), } } } impl NonterminalData { pub fn is_macro_def(&self) -> bool { !self.args.is_empty() } } impl Symbol { pub fn new(span: Span, kind: SymbolKind) -> Symbol { Symbol { span, kind } } pub fn canonical_form(&self) -> String { format!("{}", self) } } impl Name { pub fn new(mutable: bool, name: Atom) -> Self { Name { mutable, name } } pub fn immut(name: Atom) -> Self { Name::new(false, name) } } impl Display for Visibility { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { Visibility::Pub(Some(ref path)) => write!(fmt, "pub({}) ", path), Visibility::Pub(None) => write!(fmt, "pub "), Visibility::Priv => Ok(()), } } } impl Display for WhereClause { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { WhereClause::Lifetime { ref lifetime, ref bounds, } => { write!(fmt, "{}:", lifetime)?; for (i, b) in bounds.iter().enumerate() { if i != 0 { write!(fmt, " +")?; } write!(fmt, " {}", b)?; } Ok(()) } WhereClause::Type { ref forall, ref ty, ref bounds, } => { if !forall.is_empty() { write!(fmt, "for<")?; for (i, l) in forall.iter().enumerate() { if i != 0 { write!(fmt, ", ")?; } write!(fmt, "{}", l)?; } write!(fmt, "> ")?; } write!(fmt, "{}: ", ty)?; for (i, b) in bounds.iter().enumerate() { if i != 0 { write!(fmt, " +")?; } write!(fmt, " {}", b)?; } Ok(()) } } } } impl Display for TypeBound { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { TypeBound::Lifetime(ref l) => write!(fmt, "{}", l), TypeBound::Fn { ref forall, ref path, ref parameters, ref ret, } => { if !forall.is_empty() { write!(fmt, "for<")?; for (i, l) in forall.iter().enumerate() { if i != 0 { write!(fmt, ", ")?; } write!(fmt, "{}", l)?; } write!(fmt, "> ")?; } write!(fmt, "{}(", path)?; for (i, p) in parameters.iter().enumerate() { if i != 0 { write!(fmt, ", ")?; } write!(fmt, "{}", p)?; } write!(fmt, ")")?; if let Some(ref ret) = *ret { write!(fmt, " -> {}", ret)?; } Ok(()) } TypeBound::Trait { ref forall, ref path, ref parameters, } => { if !forall.is_empty() { write!(fmt, "for<")?; for (i, l) in forall.iter().enumerate() { if i != 0 { write!(fmt, ", ")?; } write!(fmt, "{}", l)?; } write!(fmt, "> ")?; } write!(fmt, "{}", path)?; if parameters.is_empty() { return Ok(()); } write!(fmt, "<")?; for (i, p) in parameters.iter().enumerate() { if i != 0 { write!(fmt, ", ")?; } write!(fmt, "{}", p)?; } write!(fmt, ">") } } } } impl Display for TypeBoundParameter { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { TypeBoundParameter::Lifetime(ref l) => write!(fmt, "{}", l), TypeBoundParameter::TypeParameter(ref t) => write!(fmt, "{}", t), TypeBoundParameter::Associated(ref id, ref t) => write!(fmt, "{} = {}", id, t), } } } impl Display for TerminalString { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { TerminalString::Literal(ref s) => write!(fmt, "{}", s), TerminalString::Bare(ref s) => write!(fmt, "{}", s), TerminalString::Error => write!(fmt, "error"), } } } impl Debug for TerminalString { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Display::fmt(self, fmt) } } impl Display for Lifetime { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Display::fmt(&self.0, fmt) } } impl Debug for Lifetime { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Display::fmt(self, fmt) } } impl Display for TerminalLiteral { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { TerminalLiteral::Quoted(ref s) => write!(fmt, "{:?}", s.as_ref()), // the Debug impl adds the `"` and escaping TerminalLiteral::Regex(ref s) => write!(fmt, "r#{:?}#", s.as_ref()), // FIXME -- need to determine proper number of # } } } impl Debug for TerminalLiteral { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}", self) } } impl Display for Path { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!( fmt, "{}{}", if self.absolute { "::" } else { "" }, Sep("::", &self.ids), ) } } impl Display for NonterminalString { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}", self.0) } } impl Debug for NonterminalString { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Display::fmt(self, fmt) } } impl Display for Symbol { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Display::fmt(&self.kind, fmt) } } impl Display for SymbolKind { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { SymbolKind::Expr(ref expr) => write!(fmt, "{}", expr), SymbolKind::Terminal(ref s) => write!(fmt, "{}", s), SymbolKind::Nonterminal(ref s) => write!(fmt, "{}", s), SymbolKind::AmbiguousId(ref s) => write!(fmt, "{}", s), SymbolKind::Macro(ref m) => write!(fmt, "{}", m), SymbolKind::Repeat(ref r) => write!(fmt, "{}", r), SymbolKind::Choose(ref s) => write!(fmt, "<{}>", s), SymbolKind::Name(ref n, ref s) => write!(fmt, "{}:{}", n, s), SymbolKind::Lookahead => write!(fmt, "@L"), SymbolKind::Lookbehind => write!(fmt, "@R"), SymbolKind::Error => write!(fmt, "error"), } } } impl Display for Name { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { if self.mutable { write!(fmt, "mut {}", self.name) } else { Display::fmt(&self.name, fmt) } } } impl Display for RepeatSymbol { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}{}", self.symbol, self.op) } } impl Display for RepeatOp { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { RepeatOp::Plus => write!(fmt, "+"), RepeatOp::Star => write!(fmt, "*"), RepeatOp::Question => write!(fmt, "?"), } } } impl Display for ExprSymbol { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "({})", Sep(" ", &self.symbols)) } } impl ExternToken { pub fn associated_type(&self, name: Atom) -> Option<&AssociatedType> { self.associated_types.iter().find(|a| a.type_name == name) } } impl ExprSymbol { pub fn canonical_form(&self) -> String { format!("{}", self) } } impl MacroSymbol { pub fn canonical_form(&self) -> String { format!("{}", self) } } impl RepeatSymbol { pub fn canonical_form(&self) -> String { format!("{}", self) } } impl Display for MacroSymbol { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}<{}>", self.name, Sep(", ", &self.args)) } } impl Display for TypeParameter { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { TypeParameter::Lifetime(ref s) => write!(fmt, "{}", s), TypeParameter::Id(ref s) => write!(fmt, "{}", s), } } } impl Display for TypeRef { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { TypeRef::Tuple(ref types) => write!(fmt, "({})", Sep(", ", types)), TypeRef::Nominal { ref path, ref types, } if types.is_empty() => write!(fmt, "{}", path), TypeRef::Nominal { ref path, ref types, } => write!(fmt, "{}<{}>", path, Sep(", ", types)), TypeRef::TraitObject { ref path, ref types, } if types.is_empty() => write!(fmt, "dyn {}", path), TypeRef::TraitObject { ref path, ref types, } => write!(fmt, "dyn {}<{}>", path, Sep(", ", types)), TypeRef::Lifetime(ref s) => write!(fmt, "{}", s), TypeRef::Id(ref s) => write!(fmt, "{}", s), TypeRef::OfSymbol(ref s) => write!(fmt, "`{}`", s), TypeRef::Ref { lifetime: None, mutable: false, ref referent, } => write!(fmt, "&{}", referent), TypeRef::Ref { lifetime: Some(ref l), mutable: false, ref referent, } => write!(fmt, "&{} {}", l, referent), TypeRef::Ref { lifetime: None, mutable: true, ref referent, } => write!(fmt, "&mut {}", referent), TypeRef::Ref { lifetime: Some(ref l), mutable: true, ref referent, } => write!(fmt, "&{} mut {}", l, referent), TypeRef::Fn { ref forall, ref path, ref parameters, ref ret, } => { write!(fmt, "dyn ")?; if !forall.is_empty() { write!(fmt, "for<{}> ", Sep(", ", forall),)?; } write!(fmt, "{}({})", path, Sep(", ", parameters))?; if let Some(ret) = ret { write!(fmt, " -> {}", ret)?; } Ok(()) } } } } impl TypeRef { // Converts a TypeRef to a TypeRepr, assuming no inference is // required etc. This is safe for all types a user can directly // type, but not safe for the result of expanding macros. pub fn type_repr(&self) -> TypeRepr { match *self { TypeRef::Tuple(ref types) => { TypeRepr::Tuple(types.iter().map(TypeRef::type_repr).collect()) } TypeRef::Nominal { ref path, ref types, } => TypeRepr::Nominal(NominalTypeRepr { path: path.clone(), types: types.iter().map(TypeRef::type_repr).collect(), }), TypeRef::Lifetime(ref id) => TypeRepr::Lifetime(id.clone()), TypeRef::Id(ref id) => TypeRepr::Nominal(NominalTypeRepr { path: Path::from_id(id.clone()), types: vec![], }), TypeRef::OfSymbol(_) => unreachable!("OfSymbol produced by parser"), TypeRef::Ref { ref lifetime, mutable, ref referent, } => TypeRepr::Ref { lifetime: lifetime.clone(), mutable, referent: Box::new(referent.type_repr()), }, TypeRef::TraitObject { ref path, ref types, } => TypeRepr::TraitObject(NominalTypeRepr { path: path.clone(), types: types.iter().map(TypeRef::type_repr).collect(), }), TypeRef::Fn { ref forall, ref path, ref parameters, ref ret, } => TypeRepr::Fn { forall: forall.clone(), path: path.clone(), parameters: parameters.iter().map(TypeRef::type_repr).collect(), ret: ret.as_ref().map(|t| Box::new(TypeRef::type_repr(t))), }, } } } impl Path { pub fn from_id(id: Atom) -> Path { Path { absolute: false, ids: vec![id], } } pub fn usize() -> Path { Path { absolute: false, ids: vec![Atom::from("usize")], } } pub fn str() -> Path { Path { absolute: false, ids: vec![Atom::from("str")], } } pub fn vec() -> Path { Path { absolute: true, ids: vec![Atom::from("std"), Atom::from("vec"), Atom::from("Vec")], } } pub fn option() -> Path { Path { absolute: true, ids: vec![ Atom::from("std"), Atom::from("option"), Atom::from("Option"), ], } } pub fn as_id(&self) -> Option { if !self.absolute && self.ids.len() == 1 { Some(self.ids[0].clone()) } else { None } } } pub fn read_algorithm(annotations: &[Annotation], algorithm: &mut r::Algorithm) { for annotation in annotations { if annotation.id == Atom::from(LALR) { algorithm.lalr = true; } else if annotation.id == Atom::from(TABLE_DRIVEN) { algorithm.codegen = r::LrCodeGeneration::TableDriven; } else if annotation.id == Atom::from(RECURSIVE_ASCENT) { algorithm.codegen = r::LrCodeGeneration::RecursiveAscent; } else if annotation.id == Atom::from(TEST_ALL) { algorithm.codegen = r::LrCodeGeneration::TestAll; } else { panic!( "validation permitted unknown annotation: {:?}", annotation.id, ); } } } lalrpop-0.17.2/src/grammar/pattern.rs000064400000000000000000000106601350346013400157020ustar0000000000000000//! The definition of patterns is shared between the parse-tree and the //! repr, but customized by a type T that represents the different type //! representations. use grammar::parse_tree::{Path, Span}; use std::fmt::{Display, Error, Formatter}; use string_cache::DefaultAtom as Atom; use util::Sep; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Pattern { pub span: Span, pub kind: PatternKind, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct FieldPattern { pub field_span: Span, pub field_name: Atom, pub pattern: Pattern, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum PatternKind { Enum(Path, Vec>), Struct(Path, Vec>, /* trailing ..? */ bool), Path(Path), Tuple(Vec>), TupleStruct(Path, Vec>), Usize(usize), Underscore, DotDot, Choose(T), CharLiteral(Atom), } impl Pattern { pub fn for_each_binding(&self, map_fn: &mut dyn FnMut(&T) -> U) { self.map(map_fn); } pub fn map(&self, map_fn: &mut dyn FnMut(&T) -> U) -> Pattern { Pattern { span: self.span, kind: self.kind.map(map_fn), } } } impl PatternKind { pub fn map(&self, map_fn: &mut dyn FnMut(&T) -> U) -> PatternKind { match *self { PatternKind::Path(ref path) => PatternKind::Path(path.clone()), PatternKind::Enum(ref path, ref pats) => PatternKind::Enum( path.clone(), pats.iter().map(|pat| pat.map(map_fn)).collect(), ), PatternKind::Struct(ref path, ref fields, dotdot) => PatternKind::Struct( path.clone(), fields.iter().map(|pat| pat.map(map_fn)).collect(), dotdot, ), PatternKind::Tuple(ref pats) => { PatternKind::Tuple(pats.iter().map(|p| p.map(map_fn)).collect()) } PatternKind::TupleStruct(ref path, ref pats) => { PatternKind::TupleStruct(path.clone(), pats.iter().map(|p| p.map(map_fn)).collect()) } PatternKind::Underscore => PatternKind::Underscore, PatternKind::DotDot => PatternKind::DotDot, PatternKind::Usize(n) => PatternKind::Usize(n), PatternKind::Choose(ref ty) => PatternKind::Choose(map_fn(ty)), PatternKind::CharLiteral(ref c) => PatternKind::CharLiteral(c.clone()), } } } impl FieldPattern { pub fn map(&self, map_fn: &mut dyn FnMut(&T) -> U) -> FieldPattern { FieldPattern { field_name: self.field_name.clone(), field_span: self.field_span, pattern: self.pattern.map(map_fn), } } } impl Display for Pattern { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}", self.kind) } } impl Display for PatternKind { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { PatternKind::Path(ref path) => write!(fmt, "{}", path), PatternKind::Enum(ref path, ref pats) => write!(fmt, "{}({})", path, Sep(", ", pats)), PatternKind::Struct(ref path, ref fields, false) => { write!(fmt, "{} {{ {} }}", path, Sep(", ", fields)) } PatternKind::Struct(ref path, ref fields, true) if fields.is_empty() => { write!(fmt, "{} {{ .. }}", path) } PatternKind::Struct(ref path, ref fields, true) => { write!(fmt, "{} {{ {}, .. }}", path, Sep(", ", fields)) } PatternKind::Tuple(ref paths) => write!(fmt, "({})", Sep(", ", paths)), PatternKind::TupleStruct(ref path, ref paths) => { write!(fmt, "{}({})", path, Sep(", ", paths)) } PatternKind::Underscore => write!(fmt, "_"), PatternKind::DotDot => write!(fmt, ".."), PatternKind::Usize(n) => write!(fmt, "{}", n), PatternKind::Choose(ref ty) => write!(fmt, "{}", ty), PatternKind::CharLiteral(ref c) => write!(fmt, "'{}'", c), } } } impl Display for FieldPattern { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}: {}", self.field_name, self.pattern) } } lalrpop-0.17.2/src/grammar/repr.rs000064400000000000000000000547241352730432300152110ustar0000000000000000//! Compiled representation of a grammar. Simplified, normalized //! version of `parse_tree`. The normalization passes produce this //! representation incrementally. use collections::{map, Map}; use grammar::free_variables::FreeVariables; use grammar::pattern::Pattern; use message::Content; use std::fmt::{Debug, Display, Error, Formatter}; use string_cache::DefaultAtom as Atom; use util::Sep; // These concepts we re-use wholesale pub use grammar::parse_tree::{ Annotation, InternToken, Lifetime, NonterminalString, Path, Span, TerminalLiteral, TerminalString, TypeBound, TypeParameter, Visibility, Name }; #[derive(Clone, Debug)] pub struct Grammar { // a unique prefix that can be appended to identifiers to ensure // that they do not conflict with any action strings pub prefix: String, // algorithm user requested for this parser pub algorithm: Algorithm, // true if the grammar mentions the `!` terminal anywhere pub uses_error_recovery: bool, // these are the nonterminals that were declared to be public; the // key is the user's name for the symbol, the value is the // artificial symbol we introduce, which will always have a single // production like `Foo' = Foo`. pub start_nonterminals: Map, // the "use foo;" statements that the user declared pub uses: Vec, // type parameters declared on the grammar, like `grammar;` pub type_parameters: Vec, // actual parameters declared on the grammar, like the `x: u32` in `grammar(x: u32);` pub parameters: Vec, // where clauses declared on the grammar, like `grammar where T: Sized` pub where_clauses: Vec, // optional tokenizer DFA; this is only needed if the user did not supply // an extern token declaration pub intern_token: Option, // the grammar proper: pub action_fn_defns: Vec, pub terminals: TerminalSet, pub nonterminals: Map, pub token_span: Span, pub conversions: Map>, pub types: Types, pub module_attributes: Vec, } #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum WhereClause { // forall<'a> WC Forall { binder: Vec, clause: Box, }, // `T: Foo` Bound { subject: TypeRepr, bound: TypeBound, }, } /// For each terminal, we map it to a small integer from 0 to N. /// This struct contains the mappings to go back and forth. #[derive(Clone, Debug)] pub struct TerminalSet { pub all: Vec, pub bits: Map, } #[derive(Clone, Debug)] pub struct NonterminalData { pub name: NonterminalString, pub visibility: Visibility, pub span: Span, pub annotations: Vec, pub productions: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Algorithm { pub lalr: bool, pub codegen: LrCodeGeneration, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum LrCodeGeneration { TableDriven, RecursiveAscent, TestAll, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Parameter { pub name: Atom, pub ty: TypeRepr, } #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct Production { // this overlaps with the key in the hashmap, obviously, but it's // handy to have it pub nonterminal: NonterminalString, pub symbols: Vec, pub action: ActionFn, pub span: Span, } #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub enum Symbol { Nonterminal(NonterminalString), Terminal(TerminalString), } #[derive(Clone, PartialEq, Eq)] pub struct ActionFnDefn { pub fallible: bool, pub ret_type: TypeRepr, pub kind: ActionFnDefnKind, } #[derive(Clone, PartialEq, Eq)] pub enum ActionFnDefnKind { User(UserActionFnDefn), Inline(InlineActionFnDefn), Lookaround(LookaroundActionFnDefn), } /// An action fn written by a user. #[derive(Clone, PartialEq, Eq)] pub struct UserActionFnDefn { pub arg_patterns: Vec, pub arg_types: Vec, pub code: String, } /// An action fn generated by the inlining pass. If we were /// inlining `A = B C D` (with action 44) into `X = Y A Z` (with /// action 22), this would look something like: /// /// ``` /// fn __action66(__0: Y, __1: B, __2: C, __3: D, __4: Z) { /// __action22(__0, __action44(__1, __2, __3), __4) /// } /// ``` #[derive(Clone, PartialEq, Eq)] pub struct InlineActionFnDefn { /// in the example above, this would be `action22` pub action: ActionFn, /// in the example above, this would be `Y, {action44: B, C, D}, Z` pub symbols: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum LookaroundActionFnDefn { Lookahead, Lookbehind, } #[derive(Clone, PartialEq, Eq)] pub enum InlinedSymbol { Original(Symbol), Inlined(ActionFn, Vec), } #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] pub enum TypeRepr { Tuple(Vec), Nominal(NominalTypeRepr), Associated { type_parameter: Atom, id: Atom, }, Lifetime(Lifetime), Ref { lifetime: Option, mutable: bool, referent: Box, }, TraitObject(NominalTypeRepr), Fn { forall: Vec, path: Path, parameters: Vec, ret: Option>, }, } impl TypeRepr { pub fn from_parameter(tp: &TypeParameter) -> Self { match tp { TypeParameter::Lifetime(l) => TypeRepr::Lifetime(l.clone()), TypeParameter::Id(name) => TypeRepr::Nominal(NominalTypeRepr { path: Path::from_id(name.clone()), types: vec![], }), } } pub fn is_unit(&self) -> bool { match *self { TypeRepr::Tuple(ref v) => v.is_empty(), _ => false, } } pub fn usize() -> TypeRepr { TypeRepr::Nominal(NominalTypeRepr { path: Path::usize(), types: vec![], }) } pub fn str() -> TypeRepr { TypeRepr::Nominal(NominalTypeRepr { path: Path::str(), types: vec![], }) } pub fn bottom_up(&self, op: &mut impl FnMut(TypeRepr) -> TypeRepr) -> Self { let result = match self { TypeRepr::Tuple(types) => { TypeRepr::Tuple(types.iter().map(|t| t.bottom_up(op)).collect()) } TypeRepr::Nominal(NominalTypeRepr { path, types }) => { TypeRepr::Nominal(NominalTypeRepr { path: path.clone(), types: types.iter().map(|t| t.bottom_up(op)).collect(), }) } TypeRepr::Associated { type_parameter, id } => TypeRepr::Associated { type_parameter: type_parameter.clone(), id: id.clone(), }, TypeRepr::Lifetime(l) => TypeRepr::Lifetime(l.clone()), TypeRepr::Ref { lifetime, mutable, referent, } => TypeRepr::Ref { lifetime: lifetime.clone(), mutable: *mutable, referent: Box::new(referent.bottom_up(op)), }, TypeRepr::TraitObject(NominalTypeRepr { path, types }) => { TypeRepr::TraitObject(NominalTypeRepr { path: path.clone(), types: types.iter().map(|t| t.bottom_up(op)).collect(), }) } TypeRepr::Fn { forall, path, parameters, ret, } => TypeRepr::Fn { forall: forall.clone(), path: path.clone(), parameters: parameters.iter().map(|t| t.bottom_up(op)).collect(), ret: ret.as_ref().map(|t| Box::new(t.bottom_up(op))), }, }; op(result) } /// Finds anonymous lifetimes (e.g., `&u32` or `Foo<'_>`) and /// instantiates them with a name like `__1`. Also computes /// obvious outlives relationships that are needed (e.g., `&'a T` /// requires `T: 'a`). The parameters `type_parameters` and /// `where_clauses` should contain -- on entry -- the /// type-parameters and where-clauses that currently exist on the /// grammar. On exit, they will have been modified to include the /// new type parameters and any implied where clauses. pub fn name_anonymous_lifetimes_and_compute_implied_outlives( &self, prefix: &str, type_parameters: &mut Vec, where_clauses: &mut Vec, ) -> Self { let fresh_lifetime_name = |type_parameters: &mut Vec| { // Make a name like `__1`: let len = type_parameters.len(); let name = Lifetime(Atom::from(format!("'{}{}", prefix, len))); type_parameters.push(TypeParameter::Lifetime(name.clone())); name }; self.bottom_up(&mut |t| match t { TypeRepr::Tuple { .. } | TypeRepr::Nominal { .. } | TypeRepr::Associated { .. } | TypeRepr::TraitObject { .. } | TypeRepr::Fn { .. } => t, TypeRepr::Lifetime(l) => { if l.is_anonymous() { TypeRepr::Lifetime(fresh_lifetime_name(type_parameters)) } else { TypeRepr::Lifetime(l) } } TypeRepr::Ref { mut lifetime, mutable, referent, } => { if lifetime.is_none() { lifetime = Some(fresh_lifetime_name(type_parameters)); } // If we have `&'a T`, then we have to compute each // free variable `X` in `T` and ensure that `X: 'a`: let l = lifetime.clone().unwrap(); for tp in referent.free_variables(type_parameters) { let wc = WhereClause::Bound { subject: TypeRepr::from_parameter(&tp), bound: TypeBound::Lifetime(l.clone()), }; if !where_clauses.contains(&wc) { where_clauses.push(wc); } } TypeRepr::Ref { lifetime, mutable, referent, } } }) } } #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] pub struct NominalTypeRepr { pub path: Path, pub types: Vec, } #[derive(Clone, Debug)] pub struct Types { terminal_token_type: TypeRepr, terminal_loc_type: Option, error_type: Option, terminal_types: Map, nonterminal_types: Map, parse_error_type: TypeRepr, error_recovery_type: TypeRepr, } impl Types { pub fn new( prefix: &str, terminal_loc_type: Option, error_type: Option, terminal_token_type: TypeRepr, ) -> Types { let mut types = Types { terminal_loc_type, error_type, terminal_token_type, terminal_types: map(), nonterminal_types: map(), // the following two will be overwritten later parse_error_type: TypeRepr::Tuple(vec![]), error_recovery_type: TypeRepr::Tuple(vec![]), }; let args = vec![ types.terminal_loc_type().clone(), types.terminal_token_type().clone(), types.error_type(), ]; types.parse_error_type = TypeRepr::Nominal(NominalTypeRepr { path: Path { absolute: false, ids: vec![ Atom::from(format!("{}lalrpop_util", prefix)), Atom::from("ParseError"), ], }, types: args.clone(), }); types.error_recovery_type = TypeRepr::Nominal(NominalTypeRepr { path: Path { absolute: false, ids: vec![ Atom::from(format!("{}lalrpop_util", prefix)), Atom::from("ErrorRecovery"), ], }, types: args, }); types .terminal_types .insert(TerminalString::Error, types.error_recovery_type.clone()); types } pub fn add_type(&mut self, nt_id: NonterminalString, ty: TypeRepr) { assert!(self.nonterminal_types.insert(nt_id, ty).is_none()); } pub fn add_term_type(&mut self, term: TerminalString, ty: TypeRepr) { assert!(self.terminal_types.insert(term, ty).is_none()); } pub fn terminal_token_type(&self) -> &TypeRepr { &self.terminal_token_type } pub fn opt_terminal_loc_type(&self) -> Option<&TypeRepr> { self.terminal_loc_type.as_ref() } pub fn terminal_loc_type(&self) -> TypeRepr { self.terminal_loc_type .clone() .unwrap_or_else(|| TypeRepr::Tuple(vec![])) } pub fn error_type(&self) -> TypeRepr { self.error_type.clone().unwrap_or_else(|| TypeRepr::Ref { lifetime: Some(Lifetime::statik()), mutable: false, referent: Box::new(TypeRepr::str()), }) } pub fn terminal_type(&self, id: &TerminalString) -> &TypeRepr { self.terminal_types .get(&id) .unwrap_or(&self.terminal_token_type) } pub fn terminal_types(&self) -> Vec { self.terminal_types.values().cloned().collect() } pub fn lookup_nonterminal_type(&self, id: &NonterminalString) -> Option<&TypeRepr> { self.nonterminal_types.get(&id) } pub fn nonterminal_type(&self, id: &NonterminalString) -> &TypeRepr { &self.nonterminal_types[&id] } pub fn nonterminal_types(&self) -> Vec { self.nonterminal_types.values().cloned().collect() } pub fn parse_error_type(&self) -> &TypeRepr { &self.parse_error_type } pub fn error_recovery_type(&self) -> &TypeRepr { &self.error_recovery_type } /// Returns a type `(L, T, L)` where L is the location type and T /// is the token type. pub fn triple_type(&self) -> TypeRepr { self.spanned_type(self.terminal_token_type().clone()) } /// Returns a type `(L, T, L)` where L is the location type and T /// is the argument. pub fn spanned_type(&self, ty: TypeRepr) -> TypeRepr { let location_type = self.terminal_loc_type(); TypeRepr::Tuple(vec![location_type.clone(), ty, location_type]) } } impl Display for WhereClause { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match self { WhereClause::Forall { binder, clause } => { write!(fmt, "for<{}> {}", Sep(", ", binder), clause) } WhereClause::Bound { subject, bound } => write!(fmt, "{}: {}", subject, bound), } } } impl Display for Parameter { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}: {}", self.name, self.ty) } } impl Display for TypeRepr { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { TypeRepr::Tuple(ref types) => write!(fmt, "({})", Sep(", ", types)), TypeRepr::Nominal(ref data) => write!(fmt, "{}", data), TypeRepr::Associated { ref type_parameter, ref id, } => write!(fmt, "{}::{}", type_parameter, id), TypeRepr::Lifetime(ref id) => write!(fmt, "{}", id), TypeRepr::Ref { lifetime: None, mutable: false, ref referent, } => write!(fmt, "&{}", referent), TypeRepr::Ref { lifetime: Some(ref l), mutable: false, ref referent, } => write!(fmt, "&{} {}", l, referent), TypeRepr::Ref { lifetime: None, mutable: true, ref referent, } => write!(fmt, "&mut {}", referent), TypeRepr::Ref { lifetime: Some(ref l), mutable: true, ref referent, } => write!(fmt, "&{} mut {}", l, referent), TypeRepr::TraitObject(ref data) => write!(fmt, "dyn {}", data), TypeRepr::Fn { ref forall, ref path, ref parameters, ref ret, } => { write!(fmt, "dyn ")?; if !forall.is_empty() { write!(fmt, "for<{}> ", Sep(", ", forall),)?; } write!(fmt, "{}({})", path, Sep(", ", parameters))?; if let Some(ret) = ret { write!(fmt, " -> {}", ret)?; } Ok(()) } } } } impl Debug for TypeRepr { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Display::fmt(self, fmt) } } impl Display for NominalTypeRepr { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { if self.types.is_empty() { write!(fmt, "{}", self.path) } else { write!(fmt, "{}<{}>", self.path, Sep(", ", &self.types)) } } } impl Debug for NominalTypeRepr { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Display::fmt(self, fmt) } } #[derive(Copy, Clone, Debug, Hash, PartialOrd, Ord, PartialEq, Eq)] pub struct ActionFn(u32); impl ActionFn { pub fn new(x: usize) -> ActionFn { ActionFn(x as u32) } pub fn index(self) -> usize { self.0 as usize } } impl Symbol { pub fn is_terminal(&self) -> bool { match *self { Symbol::Terminal(..) => true, Symbol::Nonterminal(..) => false, } } pub fn ty<'ty>(&self, t: &'ty Types) -> &'ty TypeRepr { match *self { Symbol::Terminal(ref id) => t.terminal_type(id), Symbol::Nonterminal(ref id) => t.nonterminal_type(id), } } } impl Display for Symbol { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { Symbol::Nonterminal(ref id) => write!(fmt, "{}", id.clone()), Symbol::Terminal(ref id) => write!(fmt, "{}", id.clone()), } } } impl Debug for Symbol { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Display::fmt(self, fmt) } } impl Into> for Symbol { fn into(self) -> Box { match self { Symbol::Nonterminal(nt) => nt.into(), Symbol::Terminal(term) => term.into(), } } } impl Debug for Production { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!( fmt, "{} = {} => {:?};", self.nonterminal, Sep(", ", &self.symbols), self.action, ) } } impl Debug for ActionFnDefn { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}", self.to_fn_string("_")) } } impl ActionFnDefn { fn to_fn_string(&self, name: &str) -> String { match self.kind { ActionFnDefnKind::User(ref data) => data.to_fn_string(self, name), ActionFnDefnKind::Inline(ref data) => data.to_fn_string(name), ActionFnDefnKind::Lookaround(ref data) => format!("{:?}", data), } } } impl UserActionFnDefn { fn to_fn_string(&self, defn: &ActionFnDefn, name: &str) -> String { let arg_strings: Vec = self .arg_patterns .iter() .zip(self.arg_types.iter()) .map(|(name, ty)| format!("{}: {}", name, ty)) .collect(); format!( "fn {}({}) -> {} {{ {} }}", name, Sep(", ", &arg_strings), defn.ret_type, self.code, ) } } impl InlineActionFnDefn { fn to_fn_string(&self, name: &str) -> String { let arg_strings: Vec = self .symbols .iter() .map(|inline_sym| match *inline_sym { InlinedSymbol::Original(ref s) => format!("{}", s), InlinedSymbol::Inlined(a, ref s) => format!("{:?}({})", a, Sep(", ", s)), }) .collect(); format!( "fn {}(..) {{ {:?}({}) }}", name, self.action, Sep(", ", &arg_strings), ) } } impl Grammar { pub fn pattern(&self, t: &TerminalString) -> &Pattern { &self.conversions[t] } pub fn productions_for(&self, nonterminal: &NonterminalString) -> &[Production] { match self.nonterminals.get(nonterminal) { Some(v) => &v.productions[..], None => &[], // this...probably shouldn't happen actually? } } pub fn user_parameter_refs(&self) -> String { let mut result = String::new(); for parameter in &self.parameters { result.push_str(&format!("{}, ", parameter.name)); } result } pub fn action_is_fallible(&self, f: ActionFn) -> bool { self.action_fn_defns[f.index()].fallible } pub fn non_lifetime_type_parameters(&self) -> Vec<&TypeParameter> { self.type_parameters .iter() .filter(|&tp| match *tp { TypeParameter::Lifetime(_) => false, TypeParameter::Id(_) => true, }) .collect() } } impl Default for Algorithm { fn default() -> Self { Algorithm { lalr: false, codegen: LrCodeGeneration::TableDriven, } } } lalrpop-0.17.2/src/grammar/token/mod.rs000064400000000000000000000012541346406170700161340ustar0000000000000000use std::collections::HashMap; use grammar::parse_tree::TypeRef; use string_cache::DefaultAtom as Atom; #[cfg(test)] mod test; pub struct TokenDefinition { // if the enum type is `foo::bar::baz` then: enum_type: TypeRef, // map from a custom string, like `"("` to a variant name like LPAREN token_map: HashMap, } impl TokenDefinition { pub fn new(enum_type: TypeRef, token_map: Vec<(Atom, Atom)>) -> TokenDefinition { TokenDefinition { enum_type, token_map: token_map.into_iter().collect(), } } pub fn enum_type(&self) -> &TypeRef { &self.enum_type } } lalrpop-0.17.2/src/grammar/token/test.rs000064400000000000000000000000021326645251200163200ustar0000000000000000 lalrpop-0.17.2/src/kernel_set.rs000064400000000000000000000017621341573331700147450ustar0000000000000000use collections::{map, Map}; use std::collections::VecDeque; use std::fmt::Debug; use std::hash::Hash; pub struct KernelSet { counter: usize, kernels: VecDeque, map: Map, } pub trait Kernel: Clone + Debug + Hash + Eq + PartialOrd + Ord { type Index: Copy + Debug; fn index(c: usize) -> Self::Index; } impl KernelSet { pub fn new() -> KernelSet { KernelSet { kernels: VecDeque::new(), map: map(), counter: 0, } } pub fn add_state(&mut self, kernel: K) -> K::Index { let kernels = &mut self.kernels; let counter = &mut self.counter; *self.map.entry(kernel.clone()).or_insert_with(|| { let index = *counter; *counter += 1; kernels.push_back(kernel); K::index(index) }) } pub fn next(&mut self) -> Option { self.kernels.pop_front() } } lalrpop-0.17.2/src/lexer/dfa/interpret.rs000064400000000000000000000022231341573331700164700ustar0000000000000000use lexer::dfa::{Kind, NFAIndex, DFA, START}; pub fn interpret<'text>(dfa: &DFA, input: &'text str) -> Option<(NFAIndex, &'text str)> { let mut longest: Option<(NFAIndex, usize)> = None; let mut state_index = START; for (offset, ch) in input.char_indices() { let state = &dfa.states[state_index.0]; let target = dfa .state(state_index) .test_edges .iter() .filter_map(|&(test, target)| { if test.contains_char(ch) { Some(target) } else { None } }) .next(); if let Some(target) = target { state_index = target; } else { state_index = state.other_edge; } match dfa.state(state_index).kind { Kind::Accepts(nfa) => { longest = Some((nfa, offset + ch.len_utf8())); } Kind::Reject => { break; } Kind::Neither => {} } } longest.map(|(index, offset)| (index, &input[..offset])) } lalrpop-0.17.2/src/lexer/dfa/mod.rs000064400000000000000000000231761346406170700152460ustar0000000000000000//! Constructs a DFA which picks the longest matching regular //! expression from the input. use collections::Set; use kernel_set::{Kernel, KernelSet}; use lexer::nfa::{self, NFAConstructionError, NFAStateIndex, Test, NFA}; use lexer::re; use std::fmt::{Debug, Display, Error, Formatter}; use std::rc::Rc; #[cfg(test)] mod test; #[cfg(test)] pub mod interpret; mod overlap; #[derive(Clone, Debug, PartialEq, Eq)] pub struct DFA { pub states: Vec, } #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)] pub struct Precedence(pub usize); #[derive(Debug)] pub enum DFAConstructionError { NFAConstructionError { index: NFAIndex, error: NFAConstructionError, }, /// Either of the two regexs listed could match, and they have equal /// priority. Ambiguity { match0: NFAIndex, match1: NFAIndex }, } pub fn build_dfa( regexs: &[re::Regex], precedences: &[Precedence], ) -> Result { assert_eq!(regexs.len(), precedences.len()); let nfas = regexs .iter() .enumerate() .map(|(i, r)| match NFA::from_re(r) { Ok(nfa) => Ok(nfa), Err(e) => Err(DFAConstructionError::NFAConstructionError { index: NFAIndex(i), error: e, }), }) .collect::, _>>()?; let builder = DFABuilder { nfas: &nfas, precedences: precedences.to_vec(), }; let dfa = builder.build()?; Ok(dfa) } struct DFABuilder<'nfa> { nfas: &'nfa [NFA], precedences: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct State { item_set: DFAItemSet, pub kind: Kind, pub test_edges: Vec<(Test, DFAStateIndex)>, pub other_edge: DFAStateIndex, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum Kind { Accepts(NFAIndex), Reject, Neither, } #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct NFAIndex(usize); #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct DFAStateIndex(usize); type DFAKernelSet = KernelSet; #[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] struct DFAItemSet { items: Rc>, } #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] struct Item { // which regular expression? nfa_index: NFAIndex, // what state within the NFA are we at? nfa_state: NFAStateIndex, } const START: DFAStateIndex = DFAStateIndex(0); impl<'nfa> DFABuilder<'nfa> { fn build(&self) -> Result { let mut kernel_set = KernelSet::new(); let mut states = vec![]; let start_state_index = self.start_state(&mut kernel_set); assert_eq!(start_state_index, START); while let Some(item_set) = kernel_set.next() { // collect all the specific tests we expect from any of // the items in this state let tests: Set = item_set .items .iter() .flat_map(|&item| { self.nfa(item) .edges::(item.nfa_state) .map(|edge| edge.label) }) .collect(); let tests = overlap::remove_overlap(&tests); // if any NFA is in an accepting state, that makes this // DFA state an accepting state let mut all_accepts: Vec<(Precedence, NFAIndex)> = item_set .items .iter() .cloned() .filter(|&item| self.nfa(item).is_accepting_state(item.nfa_state)) .map(|item| (self.precedences[item.nfa_index.0], item.nfa_index)) .collect(); // if all NFAs are in a rejecting state, that makes this // DFA a rejecting state let all_rejects: bool = item_set .items .iter() .all(|&item| self.nfa(item).is_rejecting_state(item.nfa_state)); let kind = if all_rejects || item_set.items.is_empty() { Kind::Reject } else if all_accepts.is_empty() { Kind::Neither } else if all_accepts.len() == 1 { // accepts just one NFA, easy case Kind::Accepts(all_accepts[0].1) } else { all_accepts.sort(); // sort regex with higher precedence, well, higher let (best_priority, best_nfa) = all_accepts[all_accepts.len() - 1]; let (next_priority, next_nfa) = all_accepts[all_accepts.len() - 2]; if best_priority == next_priority { return Err(DFAConstructionError::Ambiguity { match0: best_nfa, match1: next_nfa, }); } Kind::Accepts(best_nfa) }; // for each specific test, find what happens if we see a // character matching that test let mut test_edges: Vec<(Test, DFAStateIndex)> = tests .iter() .map(|&test| { let items: Vec<_> = item_set .items .iter() .filter_map(|&item| self.accept_test(item, test)) .collect(); // at least one of those items should accept this test assert!(!items.is_empty()); (test, kernel_set.add_state(self.transitive_closure(items))) }) .collect(); test_edges.sort(); // Consider what there is some character that doesn't meet // any of the tests. In this case, we can just ignore all // the test edges for each of the items and just union all // the "other" edges -- because if it were one of those // test edges, then that transition is represented above. let other_transitions: Vec<_> = item_set .items .iter() .filter_map(|&item| self.accept_other(item)) .collect(); // we never know the full set assert!(item_set.items.is_empty() || !other_transitions.is_empty()); let other_edge = kernel_set.add_state(self.transitive_closure(other_transitions)); let state = State { item_set, kind, test_edges, other_edge, }; states.push(state); } Ok(DFA { states }) } fn start_state(&self, kernel_set: &mut DFAKernelSet) -> DFAStateIndex { // starting state is at the beginning of all regular expressions let items: Vec<_> = (0..self.nfas.len()) .map(|i| Item { nfa_index: NFAIndex(i), nfa_state: nfa::START, }) .collect(); let item_set = self.transitive_closure(items); kernel_set.add_state(item_set) } fn accept_test(&self, item: Item, test: Test) -> Option { let nfa = self.nfa(item); let matching_test = nfa .edges::(item.nfa_state) .filter(|edge| edge.label.intersects(test)) .map(|edge| item.to(edge.to)); let matching_other = nfa .edges::(item.nfa_state) .map(|edge| item.to(edge.to)); matching_test.chain(matching_other).next() } fn accept_other(&self, item: Item) -> Option { let nfa = self.nfa(item); nfa.edges::(item.nfa_state) .map(|edge| item.to(edge.to)) .next() } fn transitive_closure(&self, mut items: Vec) -> DFAItemSet { let mut observed: Set = items.iter().cloned().collect(); let mut counter = 0; while counter < items.len() { let item = items[counter]; let derived_states = self .nfa(item) .edges::(item.nfa_state) .map(|edge| item.to(edge.to)) .filter(|&item| observed.insert(item)); items.extend(derived_states); counter += 1; } items.sort(); items.dedup(); DFAItemSet { items: Rc::new(items), } } fn nfa(&self, item: Item) -> &NFA { &self.nfas[item.nfa_index.0] } } impl Kernel for DFAItemSet { type Index = DFAStateIndex; fn index(c: usize) -> DFAStateIndex { DFAStateIndex(c) } } impl DFA { fn state(&self, index: DFAStateIndex) -> &State { &self.states[index.0] } } impl Item { fn to(&self, s: NFAStateIndex) -> Item { Item { nfa_index: self.nfa_index, nfa_state: s, } } } impl Debug for DFAStateIndex { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "DFA{}", self.0) } } impl Display for DFAStateIndex { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Debug::fmt(self, fmt) } } impl NFAIndex { pub fn index(self) -> usize { self.0 } } impl DFAStateIndex { pub fn index(self) -> usize { self.0 } } impl Debug for Item { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "({:?}:{:?})", self.nfa_index, self.nfa_state) } } lalrpop-0.17.2/src/lexer/dfa/overlap.rs000064400000000000000000000110421341573331700161230ustar0000000000000000//! When we are combining two NFAs, we will grab all the outgoing //! edges from a set of nodes and wind up with a bunch of potentially //! overlapping character ranges like: //! //! a-z //! c-l //! 0-9 //! //! This module contains code to turn those into non-overlapping ranges like: //! //! a-b //! c-l //! m-z //! 0-9 //! //! Specifically, we want to ensure that the same set of characters is //! covered when we started, and that each of the input ranges is //! covered precisely by some set of ranges in the output. use collections::Set; use lexer::nfa::Test; use std::cmp; pub fn remove_overlap(ranges: &Set) -> Vec { // We will do this in the dumbest possible way to start. :) // Maintain a result vector that contains disjoint ranges. To // insert a new range, we walk over this vector and split things // up as we go. This algorithm is so naive as to be exponential, I // think. Sue me. let mut disjoint_ranges = vec![]; for &range in ranges { add_range(range, 0, &mut disjoint_ranges); } // the algorithm above leaves some empty ranges in for simplicity; // prune them out. disjoint_ranges.retain(|r| !r.is_empty()); disjoint_ranges } fn add_range(range: Test, start_index: usize, disjoint_ranges: &mut Vec) { if range.is_empty() { return; } // Find first overlapping range in `disjoint_ranges`, if any. match disjoint_ranges[start_index..] .iter() .position(|r| r.intersects(range)) { Some(index) => { let index = index + start_index; let overlapping_range = disjoint_ranges[index]; // If the range we are trying to add already exists, we're all done. if overlapping_range == range { return; } // Otherwise, we want to create three ranges (some of which may // be empty). e.g. imagine one range is `a-z` and the other // is `c-l`, we want `a-b`, `c-l`, and `m-z`. let min_min = cmp::min(range.start, overlapping_range.start); let mid_min = cmp::max(range.start, overlapping_range.start); let mid_max = cmp::min(range.end, overlapping_range.end); let max_max = cmp::max(range.end, overlapping_range.end); let low_range = Test { start: min_min, end: mid_min, }; let mid_range = Test { start: mid_min, end: mid_max, }; let max_range = Test { start: mid_max, end: max_max, }; assert!(low_range.is_disjoint(mid_range)); assert!(low_range.is_disjoint(max_range)); assert!(mid_range.is_disjoint(max_range)); // Replace the existing range with the low range, and then // add the mid and max ranges in. (The low range may be // empty, but we'll prune that out later.) disjoint_ranges[index] = low_range; add_range(mid_range, index + 1, disjoint_ranges); add_range(max_range, index + 1, disjoint_ranges); } None => { // no overlap -- easy case. disjoint_ranges.push(range); } } } #[cfg(test)] macro_rules! test { ($($range:expr,)*) => { { use collections::set; use lexer::nfa::Test; use std::char; let mut s = set(); $({ let r = $range; s.insert(Test::exclusive_range(r.start, r.end)); })* remove_overlap(&s).into_iter() .map(|r| char::from_u32(r.start).unwrap() .. char::from_u32(r.end).unwrap()) .collect::>() } } } #[test] fn alphabet() { let result = test! { 'a' .. 'z', 'c' .. 'l', '0' .. '9', }; assert_eq!(result, vec!['0'..'9', 'a'..'c', 'c'..'l', 'l'..'z']); } #[test] fn repeat() { let result = test! { 'a' .. 'z', 'c' .. 'l', 'l' .. 'z', '0' .. '9', }; assert_eq!(result, vec!['0'..'9', 'a'..'c', 'c'..'l', 'l'..'z']); } #[test] fn stagger() { let result = test! { '0' .. '3', '2' .. '4', '3' .. '5', }; assert_eq!(result, vec!['0'..'2', '2'..'3', '3'..'4', '4'..'5']); } lalrpop-0.17.2/src/lexer/dfa/test.rs000064400000000000000000000051631346406170700154420ustar0000000000000000use lexer::dfa::interpret::interpret; use lexer::dfa::{self, DFAConstructionError, NFAIndex, Precedence, DFA}; use lexer::re; pub fn dfa(inputs: &[(&str, Precedence)]) -> Result { let regexs: Result, _> = inputs.iter().map(|&(s, _)| re::parse_regex(s)).collect(); let regexs = match regexs { Ok(rs) => rs, Err(_) => panic!("unexpected parse error"), }; let precedences: Vec<_> = inputs.iter().map(|&(_, p)| p).collect(); dfa::build_dfa(®exs, &precedences) } const P1: Precedence = Precedence(1); const P0: Precedence = Precedence(0); #[test] fn tokenizer() { let dfa = dfa(&[ (r#"class"#, P1), // 0 (r#"[a-zA-Z_][a-zA-Z0-9_]*"#, P0), // 1 (r#"[0-9]+"#, P0), // 2 (r#" +"#, P0), // 3 (r#">>"#, P0), // 4 (r#">"#, P0), // 5 ]) .unwrap(); assert_eq!(interpret(&dfa, "class Foo"), Some((NFAIndex(0), "class"))); assert_eq!(interpret(&dfa, "classz Foo"), Some((NFAIndex(1), "classz"))); assert_eq!(interpret(&dfa, "123"), Some((NFAIndex(2), "123"))); assert_eq!(interpret(&dfa, " classz Foo"), Some((NFAIndex(3), " "))); assert_eq!(interpret(&dfa, ">"), Some((NFAIndex(5), ">"))); assert_eq!(interpret(&dfa, ">>"), Some((NFAIndex(4), ">>"))); } #[test] fn ambiguous_regex() { // here the keyword and the regex have same precedence, so we have // an ambiguity assert!(dfa(&[(r#"class"#, P0), (r#"[a-zA-Z_][a-zA-Z0-9_]*"#, P0)]).is_err()); } #[test] fn issue_32() { assert!(dfa(&[(r#"."#, P0)]).is_ok()); } #[test] fn issue_35() { assert!(dfa(&[(r#".*"#, P0), (r"[-+]?[0-9]*\.?[0-9]+", P0)]).is_err()); } #[test] fn alternatives() { let dfa = dfa(&[(r#"abc|abd"#, P0)]).unwrap(); assert_eq!(interpret(&dfa, "abc"), Some((NFAIndex(0), "abc"))); assert_eq!(interpret(&dfa, "abd"), Some((NFAIndex(0), "abd"))); assert_eq!(interpret(&dfa, "123"), None); } #[test] fn alternatives_extension() { let dfa = dfa(&[(r#"abc|abcd"#, P0)]).unwrap(); assert_eq!(interpret(&dfa, "abc"), Some((NFAIndex(0), "abc"))); assert_eq!(interpret(&dfa, "abcd"), Some((NFAIndex(0), "abcd"))); assert_eq!(interpret(&dfa, "123"), None); } #[test] fn alternatives_contraction() { let dfa = dfa(&[(r#"abcd|abc"#, P0)]).unwrap(); assert_eq!(interpret(&dfa, "abc"), Some((NFAIndex(0), "abc"))); assert_eq!(interpret(&dfa, "abcd"), Some((NFAIndex(0), "abcd"))); assert_eq!(interpret(&dfa, "123"), None); } lalrpop-0.17.2/src/lexer/intern_token/mod.rs000064400000000000000000000227231350345710700172050ustar0000000000000000//! Generates an iterator type `Matcher` that looks roughly like //! //! ```ignore //! mod intern_token { //! extern crate regex as regex; //! //! #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] //! pub struct Token<'input>(pub usize, pub &'input str); //! // ~~~~~~ ~~~~~~~~~~~ //! // token token //! // index text //! // (type) //! //! impl<'a> fmt::Display for Token<'a> { ... } //! //! pub struct MatcherBuilder { //! regex_set: regex::RegexSet, //! regex_vec: Vec, //! } //! //! impl MatcherBuilder { //! fn new() -> MatchBuilder { ... } //! fn matcher<'input, 'builder>(&'builder self, s: &'input str) -> Matcher<'input, 'builder> { ... } //! } //! //! pub struct Matcher<'input, 'builder> { //! text: &'input str, //! consumed: usize, //! regex_set: &'builder regex::RegexSet, //! regex_vec: &'builder Vec, //! } //! //! impl Matcher<'input> { //! fn tokenize(&self, text: &str) -> Option<(usize, usize)> { ... } //! } //! //! impl<'input> Iterator for Matcher<'input> { //! type Item = Result<(usize, Token<'input>, usize), ParseError>; //! // ~~~~~ ~~~~~~~~~~~~~ ~~~~~ //! // start token end //! } //! } //! ``` use grammar::parse_tree::InternToken; use grammar::repr::{Grammar, TerminalLiteral}; use lexer::re; use rust::RustWrite; use std::io::{self, Write}; pub fn compile( grammar: &Grammar, intern_token: &InternToken, out: &mut RustWrite, ) -> io::Result<()> { let prefix = &grammar.prefix; rust!(out, "#[cfg_attr(rustfmt, rustfmt_skip)]"); rust!(out, "mod {}intern_token {{", prefix); rust!(out, "#![allow(unused_imports)]"); out.write_uses("", &grammar)?; rust!(out, "extern crate regex as {}regex;", prefix); rust!(out, "use std::fmt as {}fmt;", prefix); rust!(out, ""); rust!( out, "#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]" ); rust!(out, "pub struct Token<'input>(pub usize, pub &'input str);"); rust!(out, "impl<'a> {}fmt::Display for Token<'a> {{", prefix); rust!( out, "fn fmt<'f>(&self, formatter: &mut {}fmt::Formatter<'f>) -> Result<(), {}fmt::Error> {{", prefix, prefix ); rust!(out, "{}fmt::Display::fmt(self.1, formatter)", prefix); rust!(out, "}}"); rust!(out, "}}"); rust!(out, ""); rust!(out, "pub struct {}MatcherBuilder {{", prefix); rust!(out, "regex_set: {}regex::RegexSet,", prefix); rust!(out, "regex_vec: Vec<{}regex::Regex>,", prefix); rust!(out, "}}"); rust!(out, ""); rust!(out, "impl {}MatcherBuilder {{", prefix); rust!(out, "pub fn new() -> {}MatcherBuilder {{", prefix); // create a vector of rust string literals with the text of each // regular expression let regex_strings: Vec = { intern_token .match_entries .iter() .map(|match_entry| match match_entry.match_literal { TerminalLiteral::Quoted(ref s) => re::parse_literal(&s), TerminalLiteral::Regex(ref s) => re::parse_regex(&s).unwrap(), }) .map(|regex| { // make sure all regex are anchored at the beginning of the input format!("^({})", regex) }) .map(|regex_str| { // create a rust string with text of the regex; the Debug impl // will add quotes and escape format!("{:?}", regex_str) }) .collect() }; rust!(out, "let {}strs: &[&str] = &[", prefix); for literal in ®ex_strings { rust!(out, "{},", literal); } rust!(out, "];"); rust!( out, "let {}regex_set = {}regex::RegexSet::new({}strs).unwrap();", prefix, prefix, prefix ); rust!(out, "let {}regex_vec = vec![", prefix); for literal in ®ex_strings { rust!(out, "{}regex::Regex::new({}).unwrap(),", prefix, literal); } rust!(out, "];"); rust!( out, "{0}MatcherBuilder {{ regex_set: {0}regex_set, regex_vec: {0}regex_vec }}", prefix ); rust!(out, "}}"); // fn new() rust!( out, "pub fn matcher<'input, 'builder>(&'builder self, s: &'input str) \ -> {}Matcher<'input, 'builder> {{", prefix ); rust!(out, "{}Matcher {{", prefix); rust!(out, "text: s,"); rust!(out, "consumed: 0,"); rust!(out, "regex_set: &self.regex_set,"); rust!(out, "regex_vec: &self.regex_vec,"); rust!(out, "}}"); // struct literal rust!(out, "}}"); // fn matcher() rust!(out, "}}"); // impl MatcherBuilder rust!(out, ""); rust!(out, "pub struct {}Matcher<'input, 'builder> {{", prefix); rust!(out, "text: &'input str,"); // remaining input rust!(out, "consumed: usize,"); // number of chars consumed thus far rust!(out, "regex_set: &'builder {}regex::RegexSet,", prefix); rust!(out, "regex_vec: &'builder Vec<{}regex::Regex>,", prefix); rust!(out, "}}"); rust!(out, ""); rust!( out, "impl<'input, 'builder> Iterator for {}Matcher<'input, 'builder> {{", prefix ); rust!( out, "type Item = Result<(usize, Token<'input>, usize), \ {}lalrpop_util::ParseError,{}>>;", prefix, grammar.types.error_type() ); rust!(out, ""); rust!(out, "fn next(&mut self) -> Option {{"); // start by trimming whitespace from left rust!(out, "let {}text = self.text.trim_start();", prefix); rust!( out, "let {}whitespace = self.text.len() - {}text.len();", prefix, prefix ); rust!( out, "let {}start_offset = self.consumed + {}whitespace;", prefix, prefix ); // if nothing left, return None rust!(out, "if {}text.is_empty() {{", prefix); rust!(out, "self.text = {}text;", prefix); rust!(out, "self.consumed = {}start_offset;", prefix); rust!(out, "None"); rust!(out, "}} else {{"); // otherwise, use regex-set to find list of matching tokens rust!( out, "let {}matches = self.regex_set.matches({}text);", prefix, prefix ); // if nothing matched, return an error rust!(out, "if !{}matches.matched_any() {{", prefix); rust!( out, "Some(Err({}lalrpop_util::ParseError::InvalidToken {{", prefix ); rust!(out, "location: {}start_offset,", prefix); rust!(out, "}}))"); rust!(out, "}} else {{"); // otherwise, have to find longest, highest-priority match. We have the literals // sorted in order of increasing precedence, so we'll iterate over them one by one, // checking if each one matches, and remembering the longest one. rust!(out, "let mut {}longest_match = 0;", prefix); // length of longest match rust!(out, "let mut {}index = 0;", prefix); // index of longest match rust!( out, "for {}i in 0 .. {} {{", prefix, intern_token.match_entries.len() ); rust!(out, "if {}matches.matched({}i) {{", prefix, prefix); // re-run the regex to find out how long this particular match // was, then compare that against the longest-match so far. Note // that the order of the tuple is carefully constructed to ensure // that (a) we get the longest-match but (b) if two matches are // equal, we get the largest index. This is because the indices // are sorted in order of increasing priority, and because we know // that indices of equal priority cannot both match (because of // the DFA check). rust!( out, "let {}match = self.regex_vec[{}i].find({}text).unwrap();", prefix, prefix, prefix ); rust!(out, "let {}len = {}match.end();", prefix, prefix); rust!(out, "if {}len >= {}longest_match {{", prefix, prefix); rust!(out, "{}longest_match = {}len;", prefix, prefix); rust!(out, "{}index = {}i;", prefix, prefix); rust!(out, "}}"); // if is longest match rust!(out, "}}"); // if matches.matched(i) rust!(out, "}}"); // for loop // transform the result into the expected return value rust!( out, "let {}result = &{}text[..{}longest_match];", prefix, prefix, prefix ); rust!( out, "let {}remaining = &{}text[{}longest_match..];", prefix, prefix, prefix ); rust!( out, "let {}end_offset = {}start_offset + {}longest_match;", prefix, prefix, prefix ); rust!(out, "self.text = {}remaining;", prefix); rust!(out, "self.consumed = {}end_offset;", prefix); rust!( out, "Some(Ok(({}start_offset, Token({}index, {}result), {}end_offset)))", prefix, prefix, prefix, prefix ); rust!(out, "}}"); // else rust!(out, "}}"); // else rust!(out, "}}"); // fn rust!(out, "}}"); // impl rust!(out, "}}"); // mod Ok(()) } lalrpop-0.17.2/src/lexer/mod.rs000064400000000000000000000002411341573331700144770ustar0000000000000000//! Code related to generating tokenizers. #![allow(dead_code)] // not yet fully activated pub mod dfa; pub mod intern_token; pub mod nfa; pub mod re; lalrpop-0.17.2/src/lexer/nfa/interpret.rs000064400000000000000000000042621341573331700165070ustar0000000000000000//! A depth-first interpreter for NFAs. use lexer::nfa::{NFAStateIndex, Noop, Other, StateKind, Test, NFA, START}; use std::cmp::max; /// Interpret `nfa` applied to `test`, returning the longest matching /// string that we can find (if any). pub fn interpret<'text>(nfa: &NFA, text: &'text str) -> Option<&'text str> { let mut longest: Option = None; let mut stack: Vec<(NFAStateIndex, usize)> = vec![(START, 0)]; while let Some((state, offset)) = stack.pop() { match nfa.kind(state) { StateKind::Accept => match longest { None => longest = Some(offset), Some(o) => longest = Some(max(o, offset)), }, StateKind::Reject => { // the rejection state is a dead-end continue; } StateKind::Neither => {} } // transition the no-op edges, to start for edge in nfa.edges::(state) { push(&mut stack, (edge.to, offset)); } // check whether there is another character let ch = match text[offset..].chars().next() { Some(ch) => ch, // yep None => { continue; } // nope }; let offset1 = offset + ch.len_utf8(); // transition test edges let mut tests = 0; for edge in nfa.edges::(state) { if edge.label.contains_char(ch) { push(&mut stack, (edge.to, offset1)); tests += 1; } } // should *never* match more than one test, because tests // ought to be disjoint assert!(tests <= 1); // if no tests passed, use the "Other" edge if tests == 0 { for edge in nfa.edges::(state) { push(&mut stack, (edge.to, offset1)); tests += 1; } // should *never* have more than one "otherwise" edge assert!(tests <= 1); } } longest.map(|offset| &text[..offset]) } fn push(v: &mut Vec, t: T) { if !v.contains(&t) { v.push(t); } } lalrpop-0.17.2/src/lexer/nfa/mod.rs000064400000000000000000000443371346406170700152620ustar0000000000000000//! The NFA we construct for each regex. Since the states are not //! really of interest, we represent this just as a vector of labeled //! edges. use lexer::re::Regex; use regex_syntax::hir::{ Anchor, Class, ClassUnicodeRange, GroupKind, Hir, HirKind, Literal, RepetitionKind, RepetitionRange, }; use std::char; use std::fmt::{Debug, Error as FmtError, Formatter}; use std::usize; #[cfg(test)] mod interpret; #[cfg(test)] mod test; #[derive(Debug)] pub struct NFA { states: Vec, edges: Edges, } /// An edge label representing a range of characters, inclusive. Note /// that this range may contain some endpoints that are not valid /// unicode, hence we store u32. #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct Test { pub start: u32, pub end: u32, } /// An "epsilon" edge -- no input #[derive(Debug, PartialEq, Eq)] pub struct Noop; /// An "other" edge -- fallback if no other edges apply #[derive(Debug, PartialEq, Eq)] pub struct Other; /// For each state, we just store the indices of the first char and /// test edges, or usize::MAX if no such edge. You can then find all /// edges by enumerating subsequent edges in the vectors until you /// find one with a different `from` value. #[derive(Debug)] pub struct State { kind: StateKind, first_noop_edge: usize, first_test_edge: usize, first_other_edge: usize, } #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum StateKind { Accept, Reject, Neither, } #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct NFAStateIndex(usize); /// A set of edges for the state machine. Edges are kept sorted by the /// type of label they have. Within a vector, all edges with the same /// `from` are grouped together so they can be enumerated later (for /// now we just ensure this during construction, but one could easily /// sort). #[derive(Debug)] pub struct Edges { noop_edges: Vec>, // edges where we are testing the character in some way; for any // given state, there should not be multiple edges with the same // test test_edges: Vec>, // fallback rules if no test_edge applies other_edges: Vec>, } #[derive(PartialEq, Eq)] pub struct Edge { pub from: NFAStateIndex, pub label: L, pub to: NFAStateIndex, } pub const ACCEPT: NFAStateIndex = NFAStateIndex(0); pub const REJECT: NFAStateIndex = NFAStateIndex(1); pub const START: NFAStateIndex = NFAStateIndex(2); #[derive(Debug, PartialEq, Eq)] pub enum NFAConstructionError { NamedCaptures, NonGreedy, WordBoundary, LineBoundary, TextBoundary, ByteRegex, } impl NFA { pub fn from_re(regex: &Regex) -> Result { let mut nfa = NFA::new(); let s0 = nfa.expr(regex, ACCEPT, REJECT)?; nfa.push_edge(START, Noop, s0); Ok(nfa) } /////////////////////////////////////////////////////////////////////////// // Public methods for querying an NFA pub fn edges(&self, from: NFAStateIndex) -> EdgeIterator { let vec = L::vec(&self.edges); let first = *L::first(&self.states[from.0]); EdgeIterator { edges: vec, from, index: first, } } pub fn kind(&self, from: NFAStateIndex) -> StateKind { self.states[from.0].kind } pub fn is_accepting_state(&self, from: NFAStateIndex) -> bool { self.states[from.0].kind == StateKind::Accept } pub fn is_rejecting_state(&self, from: NFAStateIndex) -> bool { self.states[from.0].kind == StateKind::Reject } /////////////////////////////////////////////////////////////////////////// // Private methods for building an NFA fn new() -> NFA { let mut nfa = NFA { states: vec![], edges: Edges { noop_edges: vec![], test_edges: vec![], other_edges: vec![], }, }; // reserve the ACCEPT, REJECT, and START states ahead of time assert!(nfa.new_state(StateKind::Accept) == ACCEPT); assert!(nfa.new_state(StateKind::Reject) == REJECT); assert!(nfa.new_state(StateKind::Neither) == START); // the ACCEPT state, given another token, becomes a REJECT nfa.push_edge(ACCEPT, Other, REJECT); // the REJECT state loops back to itself no matter what nfa.push_edge(REJECT, Other, REJECT); nfa } fn new_state(&mut self, kind: StateKind) -> NFAStateIndex { let index = self.states.len(); // these edge indices will be patched later by patch_edges() self.states.push(State { kind, first_noop_edge: usize::MAX, first_test_edge: usize::MAX, first_other_edge: usize::MAX, }); NFAStateIndex(index) } // pushes an edge: note that all outgoing edges from a particular // state should be pushed together, so that the edge vectors are // suitably sorted fn push_edge(&mut self, from: NFAStateIndex, label: L, to: NFAStateIndex) { let edge_vec = L::vec_mut(&mut self.edges); let edge_index = edge_vec.len(); edge_vec.push(Edge { from, label, to }); // if this is the first edge from the `from` state, set the // index let first_index = L::first_mut(&mut self.states[from.0]); if *first_index == usize::MAX { *first_index = edge_index; } else { // otherwise, check that all edges are continuous assert_eq!(edge_vec[edge_index - 1].from, from); } } fn expr( &mut self, expr: &Hir, accept: NFAStateIndex, reject: NFAStateIndex, ) -> Result { match *expr.kind() { HirKind::Empty => Ok(accept), HirKind::Literal(ref l) => { match *l { // [s0] -otherwise-> [accept] Literal::Unicode(c) => { let s0 = self.new_state(StateKind::Neither); self.push_edge(s0, Test::char(c), accept); self.push_edge(s0, Other, reject); Ok(s0) } // Bytes are not supported Literal::Byte(_) => Err(NFAConstructionError::ByteRegex), } } HirKind::Class(ref class) => { match *class { Class::Unicode(ref uc) => // [s0] --c0--> [accept] // | | ^ // | | ... | // | | | // | +---cn-------+ // +---------------> [reject] { let s0 = self.new_state(StateKind::Neither); for &range in uc.iter() { let test: Test = range.into(); self.push_edge(s0, test, accept); } self.push_edge(s0, Other, reject); Ok(s0) } // Bytes are not supported Class::Bytes(_) => Err(NFAConstructionError::ByteRegex), } } // currently we don't support any boundaries because // I was too lazy to code them up or think about them HirKind::WordBoundary(_) => Err(NFAConstructionError::WordBoundary), HirKind::Anchor(ref a) => match a { Anchor::StartLine | Anchor::EndLine => Err(NFAConstructionError::LineBoundary), Anchor::StartText | Anchor::EndText => Err(NFAConstructionError::TextBoundary), }, // currently we treat all groups the same, whether they // capture or not; but we don't permit named groups, // in case we want to give them significance in the future HirKind::Group(ref g) => match g.kind { GroupKind::CaptureName { .. } => Err(NFAConstructionError::NamedCaptures), GroupKind::CaptureIndex(_) | GroupKind::NonCapturing => { self.expr(&g.hir, accept, reject) } }, HirKind::Repetition(ref r) => { if !r.greedy { // currently we always report the longest match possible Err(NFAConstructionError::NonGreedy) } else { match r.kind { RepetitionKind::ZeroOrOne => self.optional_expr(&r.hir, accept, reject), RepetitionKind::ZeroOrMore => self.star_expr(&r.hir, accept, reject), RepetitionKind::OneOrMore => self.plus_expr(&r.hir, accept, reject), RepetitionKind::Range(ref range) => { match *range { RepetitionRange::Exactly(c) => { let mut s = accept; for _ in 0..c { s = self.expr(&r.hir, s, reject)?; } Ok(s) } RepetitionRange::AtLeast(min) => { // +---min times----+ // | | // // [s0] --..e..-- [s1] --..e*..--> [accept] // | | // | v // +-> [reject] let mut s = self.star_expr(&r.hir, accept, reject)?; for _ in 0..min { s = self.expr(&r.hir, s, reject)?; } Ok(s) } RepetitionRange::Bounded(min, max) => { let mut s = accept; for _ in min..max { s = self.optional_expr(&r.hir, s, reject)?; } for _ in 0..min { s = self.expr(&r.hir, s, reject)?; } Ok(s) } } } } } } HirKind::Concat(ref exprs) => { let mut s = accept; for expr in exprs.iter().rev() { s = self.expr(expr, s, reject)?; } Ok(s) } HirKind::Alternation(ref exprs) => { // [s0] --exprs[0]--> [accept/reject] // | ^ // | | // +----exprs[..]------+ // | | // | | // +----exprs[n-1]-----+ let s0 = self.new_state(StateKind::Neither); let targets: Vec<_> = exprs .iter() .map(|expr| self.expr(expr, accept, reject)) .collect::, _>>()?; // push edges from s0 all together so they are // adjacant in the edge array for target in targets { self.push_edge(s0, Noop, target); } Ok(s0) } } } fn optional_expr( &mut self, expr: &Hir, accept: NFAStateIndex, reject: NFAStateIndex, ) -> Result { // [s0] ----> [accept] // | ^ // v | // [s1] --...----+ // | // v // [reject] let s1 = self.expr(expr, accept, reject)?; let s0 = self.new_state(StateKind::Neither); self.push_edge(s0, Noop, accept); // they might supply nothing self.push_edge(s0, Noop, s1); Ok(s0) } fn star_expr( &mut self, expr: &Hir, accept: NFAStateIndex, reject: NFAStateIndex, ) -> Result { // [s0] ----> [accept] // | ^ // | | // | +----------+ // v | // [s1] --...----+ // | // v // [reject] let s0 = self.new_state(StateKind::Neither); let s1 = self.expr(expr, s0, reject)?; self.push_edge(s0, Noop, accept); self.push_edge(s0, Noop, s1); Ok(s0) } fn plus_expr( &mut self, expr: &Hir, accept: NFAStateIndex, reject: NFAStateIndex, ) -> Result { // [accept] // ^ // | // +----------+ // v | // [s0] --...--[s1] // | // v // [reject] let s1 = self.new_state(StateKind::Neither); let s0 = self.expr(expr, s1, reject)?; self.push_edge(s1, Noop, accept); self.push_edge(s1, Noop, s0); Ok(s0) } } pub trait EdgeLabel: Sized { fn vec_mut(nfa: &mut Edges) -> &mut Vec>; fn vec(nfa: &Edges) -> &Vec>; fn first_mut(state: &mut State) -> &mut usize; fn first(state: &State) -> &usize; } impl EdgeLabel for Noop { fn vec_mut(nfa: &mut Edges) -> &mut Vec> { &mut nfa.noop_edges } fn first_mut(state: &mut State) -> &mut usize { &mut state.first_noop_edge } fn vec(nfa: &Edges) -> &Vec> { &nfa.noop_edges } fn first(state: &State) -> &usize { &state.first_noop_edge } } impl EdgeLabel for Other { fn vec_mut(nfa: &mut Edges) -> &mut Vec> { &mut nfa.other_edges } fn first_mut(state: &mut State) -> &mut usize { &mut state.first_other_edge } fn vec(nfa: &Edges) -> &Vec> { &nfa.other_edges } fn first(state: &State) -> &usize { &state.first_other_edge } } impl EdgeLabel for Test { fn vec_mut(nfa: &mut Edges) -> &mut Vec> { &mut nfa.test_edges } fn first_mut(state: &mut State) -> &mut usize { &mut state.first_test_edge } fn vec(nfa: &Edges) -> &Vec> { &nfa.test_edges } fn first(state: &State) -> &usize { &state.first_test_edge } } pub struct EdgeIterator<'nfa, L: EdgeLabel + 'nfa> { edges: &'nfa [Edge], from: NFAStateIndex, index: usize, } impl<'nfa, L: EdgeLabel> Iterator for EdgeIterator<'nfa, L> { type Item = &'nfa Edge; fn next(&mut self) -> Option<&'nfa Edge> { let index = self.index; if index == usize::MAX { return None; } let next_index = index + 1; if next_index >= self.edges.len() || self.edges[next_index].from != self.from { self.index = usize::MAX; } else { self.index = next_index; } Some(&self.edges[index]) } } impl Test { pub fn char(c: char) -> Test { let c = c as u32; Test { start: c, end: c + 1, } } pub fn inclusive_range(s: char, e: char) -> Test { Test { start: s as u32, end: e as u32 + 1, } } pub fn exclusive_range(s: char, e: char) -> Test { Test { start: s as u32, end: e as u32, } } pub fn is_char(self) -> bool { self.len() == 1 } pub fn len(self) -> u32 { self.end - self.start } pub fn contains_u32(self, c: u32) -> bool { c >= self.start && c < self.end } pub fn contains_char(self, c: char) -> bool { self.contains_u32(c as u32) } pub fn intersects(self, r: Test) -> bool { !self.is_empty() && !r.is_empty() && (self.contains_u32(r.start) || r.contains_u32(self.start)) } pub fn is_disjoint(self, r: Test) -> bool { !self.intersects(r) } pub fn is_empty(self) -> bool { self.start == self.end } } impl From for Test { fn from(range: ClassUnicodeRange) -> Test { Test::inclusive_range(range.start(), range.end()) } } impl Debug for Test { fn fmt(&self, fmt: &mut Formatter) -> Result<(), FmtError> { match (char::from_u32(self.start), char::from_u32(self.end)) { (Some(start), Some(end)) => { if self.is_char() { if ".[]()?+*!".contains(start) { write!(fmt, "\\{}", start) } else { write!(fmt, "{}", start) } } else { write!(fmt, "[{:?}..{:?}]", start, end) } } _ => write!(fmt, "[{:?}..{:?}]", self.start, self.end), } } } impl Debug for NFAStateIndex { fn fmt(&self, fmt: &mut Formatter) -> Result<(), FmtError> { write!(fmt, "NFA{}", self.0) } } impl Debug for Edge { fn fmt(&self, fmt: &mut Formatter) -> Result<(), FmtError> { write!(fmt, "{:?} -{:?}-> {:?}", self.from, self.label, self.to) } } lalrpop-0.17.2/src/lexer/nfa/test.rs000064400000000000000000000114631341573331700154530ustar0000000000000000use lexer::nfa::interpret::interpret; use lexer::nfa::{NFAConstructionError, Noop, Other, StateKind, Test, NFA}; use lexer::re; #[test] fn edge_iter() { let mut nfa = NFA::new(); let s0 = nfa.new_state(StateKind::Neither); let s1 = nfa.new_state(StateKind::Neither); let s2 = nfa.new_state(StateKind::Neither); let s3 = nfa.new_state(StateKind::Neither); nfa.push_edge(s2, Noop, s3); nfa.push_edge(s0, Noop, s1); nfa.push_edge(s0, Noop, s3); nfa.push_edge(s1, Noop, s2); // check that if we mixed up the indies between Noop/Other, we'd get wrong thing here nfa.push_edge(s0, Other, s2); let s0_edges: Vec<_> = nfa.edges::(s0).map(|e| e.to).collect(); let s1_edges: Vec<_> = nfa.edges::(s1).map(|e| e.to).collect(); let s2_edges: Vec<_> = nfa.edges::(s2).map(|e| e.to).collect(); let s3_edges: Vec<_> = nfa.edges::(s3).map(|e| e.to).collect(); let s0_other_edges: Vec<_> = nfa.edges::(s0).map(|e| e.to).collect(); let s0_test_edges: Vec<_> = nfa.edges::(s0).map(|e| e.to).collect(); assert_eq!(s0_edges, &[s1, s3]); assert_eq!(s1_edges, &[s2]); assert_eq!(s2_edges, &[s3]); assert_eq!(s3_edges, &[]); assert_eq!(s0_other_edges, &[s2]); assert_eq!(s0_test_edges, &[]); } #[test] fn identifier_regex() { let ident = re::parse_regex(r#"[a-zA-Z_][a-zA-Z0-9_]*"#).unwrap(); println!("{:#?}", ident); let nfa = NFA::from_re(&ident).unwrap(); println!("{:#?}", nfa); assert_eq!(interpret(&nfa, "0123"), None); assert_eq!(interpret(&nfa, "hello0123"), Some("hello0123")); assert_eq!(interpret(&nfa, "hello0123 abc"), Some("hello0123")); assert_eq!(interpret(&nfa, "_0123 abc"), Some("_0123")); } #[test] fn regex_star_group() { let ident = re::parse_regex(r#"(abc)*"#).unwrap(); let nfa = NFA::from_re(&ident).unwrap(); assert_eq!(interpret(&nfa, "abcabcabcab"), Some("abcabcabc")); } #[test] fn regex_number() { let num = re::parse_regex(r#"[0-9]+"#).unwrap(); let nfa = NFA::from_re(&num).unwrap(); assert_eq!(interpret(&nfa, "123"), Some("123")); } #[test] fn dot_newline() { let num = re::parse_regex(r#"."#).unwrap(); let nfa = NFA::from_re(&num).unwrap(); assert_eq!(interpret(&nfa, "\n"), None); } #[test] fn max_range() { let num = re::parse_regex(r#"ab{2,4}"#).unwrap(); let nfa = NFA::from_re(&num).unwrap(); assert_eq!(interpret(&nfa, "a"), None); assert_eq!(interpret(&nfa, "ab"), None); assert_eq!(interpret(&nfa, "abb"), Some("abb")); assert_eq!(interpret(&nfa, "abbb"), Some("abbb")); assert_eq!(interpret(&nfa, "abbbb"), Some("abbbb")); assert_eq!(interpret(&nfa, "abbbbb"), Some("abbbb")); assert_eq!(interpret(&nfa, "ac"), None); } #[test] fn literal() { let num = re::parse_regex(r#"(?i:aBCdeF)"#).unwrap(); let nfa = NFA::from_re(&num).unwrap(); assert_eq!(interpret(&nfa, "abcdef"), Some("abcdef")); assert_eq!(interpret(&nfa, "AbcDEf"), Some("AbcDEf")); } // Test that uses of disallowed features trigger errors // during NFA construction: #[test] fn captures() { let num = re::parse_regex(r#"(aBCdeF)"#).unwrap(); NFA::from_re(&num).unwrap(); // captures are ok let num = re::parse_regex(r#"(?:aBCdeF)"#).unwrap(); NFA::from_re(&num).unwrap(); // non-captures are ok let num = re::parse_regex(r#"(?PaBCdeF)"#).unwrap(); // named captures are not assert_eq!( NFA::from_re(&num).unwrap_err(), NFAConstructionError::NamedCaptures ); } #[test] fn line_boundaries() { let num = re::parse_regex(r#"^aBCdeF"#).unwrap(); assert_eq!( NFA::from_re(&num).unwrap_err(), NFAConstructionError::TextBoundary ); let num = re::parse_regex(r#"aBCdeF$"#).unwrap(); assert_eq!( NFA::from_re(&num).unwrap_err(), NFAConstructionError::TextBoundary ); } #[test] fn text_boundaries() { let num = re::parse_regex(r#"(?m)^aBCdeF"#).unwrap(); assert_eq!( NFA::from_re(&num).unwrap_err(), NFAConstructionError::LineBoundary ); let num = re::parse_regex(r#"(?m)aBCdeF$"#).unwrap(); assert_eq!( NFA::from_re(&num).unwrap_err(), NFAConstructionError::LineBoundary ); } #[test] fn word_boundaries() { let num = re::parse_regex(r#"\baBCdeF"#).unwrap(); assert_eq!( NFA::from_re(&num).unwrap_err(), NFAConstructionError::WordBoundary ); let num = re::parse_regex(r#"aBCdeF\B"#).unwrap(); assert_eq!( NFA::from_re(&num).unwrap_err(), NFAConstructionError::WordBoundary ); } #[test] fn issue_101() { let num = re::parse_regex(r#"(1|0?)"#).unwrap(); NFA::from_re(&num).unwrap(); } lalrpop-0.17.2/src/lexer/re/mod.rs000064400000000000000000000012021341573331700151030ustar0000000000000000//! A parser and representation of regular expressions. use regex_syntax::hir::Hir; use regex_syntax::{self, Error, Parser}; #[cfg(test)] mod test; pub type Regex = Hir; pub type RegexError = Error; /// Convert a string literal into a parsed regular expression. pub fn parse_literal(s: &str) -> Regex { match parse_regex(®ex_syntax::escape(s)) { Ok(v) => v, Err(_) => panic!("failed to parse literal regular expression"), } } /// Parse a regular expression like `a+` etc. pub fn parse_regex(s: &str) -> Result { let expr = Parser::new().parse(s)?; Ok(expr) } lalrpop-0.17.2/src/lexer/re/test.rs000064400000000000000000000002521326645251200153060ustar0000000000000000use super::*; #[test] fn parse_unclosed_group() { parse_regex(r"(123").unwrap_err(); } #[test] fn alt_oom() { parse_regex(r"(%%|[^%])+").unwrap(); } lalrpop-0.17.2/src/lib.rs000064400000000000000000000022161346225060300133450ustar0000000000000000// Need this for rusty_peg #![recursion_limit = "256"] // I hate this lint. #![allow(unused_parens)] // The builtin tests don't cover the CLI and so forth, and it's just // too darn annoying to try and make them do so. #![cfg_attr(test, allow(dead_code))] extern crate ascii_canvas; extern crate atty; extern crate bit_set; extern crate diff; extern crate ena; extern crate itertools; #[cfg_attr(feature = "test", macro_use)] extern crate lalrpop_util; extern crate petgraph; extern crate regex; extern crate regex_syntax; extern crate sha2; extern crate string_cache; extern crate term; extern crate unicode_xid; #[cfg(test)] extern crate rand; // hoist the modules that define macros up earlier #[macro_use] mod rust; #[macro_use] mod log; mod api; mod build; mod collections; mod file_text; mod grammar; mod kernel_set; mod lexer; mod lr1; mod message; mod normalize; mod parser; mod session; mod tls; mod tok; mod util; #[cfg(test)] mod generate; #[cfg(test)] mod test_util; pub use api::process_root; pub use api::process_root_unconditionally; pub use api::Configuration; use ascii_canvas::style; lalrpop-0.17.2/src/log.rs000064400000000000000000000031371346406170700133720ustar0000000000000000#[derive(Clone)] pub struct Log { level: Level, } #[derive(Clone, PartialOrd, Ord, PartialEq, Eq)] pub enum Level { /// No updates unless an error arises. Taciturn, /// Timing and minimal progress. Informative, /// More details, but still stuff an end-user is likely to understand. Verbose, /// Everything you could ever want and then some more. Debug, } impl Log { pub fn new(level: Level) -> Log { Log { level } } pub fn set_level(&mut self, level: Level) { self.level = level; } pub fn log(&self, level: Level, message: M) where M: FnOnce() -> String, { if self.level >= level { println!("{}", message()); } } } macro_rules! log { ($session:expr, $level:ident, $($args:expr),*) => { $session.log(::log::Level::$level, || ::std::fmt::format(format_args!($($args),*))) } } macro_rules! debug { ($($args:expr),*) => { log!(::tls::Tls::session(), Debug, $($args),*) } } macro_rules! profile { ($session:expr, $phase_name:expr, $action:expr) => {{ log!($session, Verbose, "Phase `{}` begun", $phase_name); let time_stamp = ::std::time::Instant::now(); let result = $action; let elapsed = time_stamp.elapsed(); log!( $session, Verbose, "Phase `{}` completed in {} seconds", $phase_name, elapsed.as_secs() as f64 + elapsed.subsec_nanos() as f64 / 1_000_000_000.0 ); result }}; } lalrpop-0.17.2/src/lr1/build/mod.rs000064400000000000000000000276361346406170700151770ustar0000000000000000//! LR(1) state construction algorithm. use collections::{map, Multimap}; use grammar::repr::*; use kernel_set; use lr1::core::*; use lr1::first; use lr1::lane_table::*; use lr1::lookahead::*; use std::env; use std::rc::Rc; use tls::Tls; #[cfg(test)] mod test; fn build_lr1_states_legacy<'grammar>( grammar: &'grammar Grammar, start: NonterminalString, ) -> LR1Result<'grammar> { let eof = TokenSet::eof(); let mut lr1: LR<'grammar, TokenSet> = LR::new(grammar, start, eof); lr1.set_permit_early_stop(true); lr1.build_states() } type ConstructionFunction<'grammar> = fn(&'grammar Grammar, NonterminalString) -> LR1Result<'grammar>; pub fn use_lane_table() -> bool { match env::var("LALRPOP_LANE_TABLE") { Ok(ref s) => s != "disabled", _ => true, } } pub fn build_lr1_states<'grammar>( grammar: &'grammar Grammar, start: NonterminalString, ) -> LR1Result<'grammar> { let (method_name, method_fn) = if use_lane_table() { ("lane", build_lane_table_states as ConstructionFunction) } else { ("legacy", build_lr1_states_legacy as ConstructionFunction) }; profile! { &Tls::session(), format!("LR(1) state construction ({})", method_name), { method_fn(grammar, start) } } } pub fn build_lr0_states<'grammar>( grammar: &'grammar Grammar, start: NonterminalString, ) -> Result>, LR0TableConstructionError<'grammar>> { let lr1 = LR::new(grammar, start, Nil); lr1.build_states() } pub struct LR<'grammar, L: LookaheadBuild> { grammar: &'grammar Grammar, first_sets: first::FirstSets, start_nt: NonterminalString, start_lookahead: L, permit_early_stop: bool, } impl<'grammar, L: LookaheadBuild> LR<'grammar, L> { fn new(grammar: &'grammar Grammar, start_nt: NonterminalString, start_lookahead: L) -> Self { LR { grammar, first_sets: first::FirstSets::new(grammar), start_nt, start_lookahead, permit_early_stop: false, } } fn set_permit_early_stop(&mut self, v: bool) { self.permit_early_stop = v; } fn build_states(&self) -> Result>, TableConstructionError<'grammar, L>> { let session = Tls::session(); let mut kernel_set = kernel_set::KernelSet::new(); let mut states = vec![]; let mut conflicts = vec![]; // create the starting state kernel_set.add_state(Kernel::start(self.items( &self.start_nt, 0, &self.start_lookahead, ))); while let Some(Kernel { items: seed_items }) = kernel_set.next() { let items = self.transitive_closure(seed_items); let index = StateIndex(states.len()); if index.0 % 5000 == 0 && index.0 > 0 { log!(session, Verbose, "{} states created so far.", index.0); } let mut this_state = State { index, items: items.clone(), shifts: map(), reductions: vec![], gotos: map(), }; // group the items that we can transition into by shifting // over a term or nonterm let transitions: Multimap, L>> = items .vec .iter() .filter_map(Item::shifted_item) .map( |( symbol, Item { production, index, lookahead, }, )| { (symbol, (Item::lr0(production, index), lookahead)) }, ) .collect(); for (symbol, shifted_items) in transitions.into_iter() { let shifted_items: Vec> = shifted_items .into_iter() .map(|(lr0_item, lookahead)| lr0_item.with_lookahead(lookahead)) .collect(); // Not entirely obvious: if the original set of items // is sorted to begin with (and it is), then this new // set of shifted items is *also* sorted. This is // because it is produced from the old items by simply // incrementing the index by 1. let next_state = kernel_set.add_state(Kernel::shifted(shifted_items)); match symbol { Symbol::Terminal(s) => { let prev = this_state.shifts.insert(s, next_state); assert!(prev.is_none()); // cannot have a shift/shift conflict } Symbol::Nonterminal(s) => { let prev = this_state.gotos.insert(s, next_state); assert!(prev.is_none()); } } } // finally, consider the reductions for item in items.vec.iter().filter(|i| i.can_reduce()) { this_state .reductions .push((item.lookahead.clone(), item.production)); } // check for shift-reduce conflicts (reduce-reduce detected above) conflicts.extend(L::conflicts(&this_state)); // extract a new state states.push(this_state); if self.permit_early_stop && session.stop_after(conflicts.len()) { log!( session, Verbose, "{} conflicts encountered, stopping.", conflicts.len() ); break; } } if !conflicts.is_empty() { Err(TableConstructionError { states, conflicts }) } else { Ok(states) } } fn items(&self, id: &NonterminalString, index: usize, lookahead: &L) -> Vec> { self.grammar .productions_for(id) .iter() .map(|production| { debug_assert!(index <= production.symbols.len()); Item { production, index, lookahead: lookahead.clone(), } }) .collect() } // expands `state` with epsilon moves fn transitive_closure(&self, items: Vec>) -> Items<'grammar, L> { let mut stack: Vec> = items.iter().map(Item::to_lr0).collect(); let mut map: Multimap, L> = items .into_iter() .map(|item| (item.to_lr0(), item.lookahead)) .collect(); while let Some(item) = stack.pop() { let lookahead = map.get(&item).unwrap().clone(); let shift_symbol = item.shift_symbol(); // Check whether this is an item where the cursor // is resting on a non-terminal: // // I = ... (*) X z... [lookahead] // // The `nt` will be X and the `remainder` will be `z...`. let (nt, remainder) = match shift_symbol { None => continue, // requires a reduce Some((Symbol::Terminal(_), _)) => { continue; // requires a shift } Some((Symbol::Nonterminal(nt), remainder)) => (nt, remainder), }; // In that case, for each production of `X`, we are also // in a state where the cursor rests at the start of that production: // // X = (*) a... [lookahead'] // X = (*) b... [lookahead'] // // Here `lookahead'` is computed based on the `remainder` and our // `lookahead`. In LR1 at least, it is the union of: // // (a) FIRST(remainder) // (b) if remainder may match epsilon, also our lookahead. for new_item in L::epsilon_moves(self, &nt, remainder, &lookahead) { let new_item0 = new_item.to_lr0(); if map.push(new_item0, new_item.lookahead) { stack.push(new_item0); } } } let final_items = map .into_iter() .map(|(lr0_item, lookahead)| lr0_item.with_lookahead(lookahead)) .collect(); Items { vec: Rc::new(final_items), } } } /// Except for the initial state, the kernel sets always contain /// a set of "seed" items where something has been pushed (that is, /// index > 0). In other words, items like this: /// /// A = ...p (*) ... /// /// where ...p is non-empty. We now have to expand to include any /// epsilon moves: /// /// A = ... (*) B ... /// B = (*) ... // added by transitive_closure algorithm /// /// But note that the state is completely identified by its /// kernel set: the same kernel sets always expand to the /// same transitive closures, and different kernel sets /// always expand to different transitive closures. The /// first point is obvious, but the latter point follows /// because the transitive closure algorithm only adds /// items where `index == 0`, and hence it can never add an /// item found in a kernel set. #[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] struct Kernel<'grammar, L: LookaheadBuild> { items: Vec>, } impl<'grammar, L: LookaheadBuild> Kernel<'grammar, L> { pub fn start(items: Vec>) -> Kernel<'grammar, L> { // In start state, kernel should have only items with `index == 0`. debug_assert!(items.iter().all(|item| item.index == 0)); Kernel { items } } pub fn shifted(items: Vec>) -> Kernel<'grammar, L> { // Assert that this kernel consists only of shifted items // where `index > 0`. This assertion could cost real time to // check so only do it in debug mode. debug_assert!(items.iter().all(|item| item.index > 0)); Kernel { items } } } impl<'grammar, L: LookaheadBuild> kernel_set::Kernel for Kernel<'grammar, L> { type Index = StateIndex; fn index(c: usize) -> StateIndex { StateIndex(c) } } pub trait LookaheadBuild: Lookahead { // Given that there exists an item // // X = ... (*) Y ...s [L] // // where `nt` is `Y`, `remainder` is `...s`, and `lookahead` is // `L`, computes the new items resulting from epsilon moves (if // any). The technique of doing this will depend on the amount of // lookahead. // // For example, if we have an LR0 item, then for each `Y = ...` // production, we just add an `Y = (*) ...` item. But for LR1 // items, we have to add multiple items where we consider the // lookahead from `FIRST(...s, L)`. fn epsilon_moves<'grammar>( lr: &LR<'grammar, Self>, nt: &NonterminalString, remainder: &[Symbol], lookahead: &Self, ) -> Vec>; } impl LookaheadBuild for Nil { fn epsilon_moves<'grammar>( lr: &LR<'grammar, Self>, nt: &NonterminalString, _remainder: &[Symbol], lookahead: &Nil, ) -> Vec> { lr.items(nt, 0, &lookahead) } } impl LookaheadBuild for TokenSet { fn epsilon_moves<'grammar>( lr: &LR<'grammar, Self>, nt: &NonterminalString, remainder: &[Symbol], lookahead: &Self, ) -> Vec> { let first_set = lr.first_sets.first1(remainder, lookahead); lr.items(nt, 0, &first_set) } } lalrpop-0.17.2/src/lr1/build/test.rs000064400000000000000000000172631341573331700153710ustar0000000000000000use generate; use grammar::repr::*; use lr1::core::*; use lr1::interpret::interpret; use lr1::lookahead::Token; use lr1::lookahead::Token::EOF; use lr1::lookahead::TokenSet; use lr1::tls::Lr1Tls; use string_cache::DefaultAtom as Atom; use test_util::{compare, expect_debug, normalized_grammar}; use tls::Tls; use super::{build_lr0_states, build_lr1_states, use_lane_table, LR}; fn nt(t: &str) -> NonterminalString { NonterminalString(Atom::from(t)) } const ITERATIONS: usize = 22; fn random_test<'g>(grammar: &Grammar, states: &'g [LR1State<'g>], start_symbol: NonterminalString) { for i in 0..ITERATIONS { let input_tree = generate::random_parse_tree(grammar, start_symbol.clone()); let output_tree = interpret(&states, input_tree.terminals()).unwrap(); println!("test {}", i); println!("input_tree = {}", input_tree); println!("output_tree = {}", output_tree); compare(output_tree, input_tree); } } macro_rules! tokens { ($($x:expr),*) => { vec![$(TerminalString::quoted(Atom::from($x))),*] } } fn items<'g>(grammar: &'g Grammar, nonterminal: &str, index: usize, la: Token) -> LR1Items<'g> { let set = TokenSet::from(la); let lr1: LR = LR::new(&grammar, nt(nonterminal), set.clone()); let items = lr1.transitive_closure(lr1.items(&nt(nonterminal), index, &set)); items } #[test] fn start_state() { let grammar = normalized_grammar( r#" grammar; extern { enum Tok { "C" => .., "D" => .. } } A = B "C"; B: Option = { "D" => Some(1), () => None }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let items = items(&grammar, "A", 0, EOF); expect_debug( items.vec, r#"[ A = (*) B "C" [EOF], B = (*) ["C"], B = (*) "D" ["C"] ]"#, ); } #[test] fn start_state_1() { let grammar = normalized_grammar( r#" grammar; extern { enum Tok { "B1" => .., "C1" => .. } } A = B C; B: Option = { "B1" => Some(1), () => None }; C: Option = { "C1" => Some(1), () => None }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); expect_debug( items(&grammar, "A", 0, EOF).vec, r#"[ A = (*) B C [EOF], B = (*) ["C1", EOF], B = (*) "B1" ["C1", EOF] ]"#, ); expect_debug( items(&grammar, "A", 1, EOF).vec, r#"[ A = B (*) C [EOF], C = (*) [EOF], C = (*) "C1" [EOF] ]"#, ); } #[test] fn expr_grammar1() { let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; extern { enum Tok { "-" => .., "N" => .., "(" => .., ")" => .. } } S: () = E => (); E: () = { E "-" T => (), T => () }; T: () = { "N" => (), "(" E ")" => () }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); // for now, just test that process does not result in an error // and yields expected number of states. let states = build_lr1_states(&grammar, nt("S")).unwrap(); println!("{:#?}", states); assert_eq!(states.len(), if use_lane_table() { 9 } else { 16 }); // execute it on some sample inputs. let tree = interpret(&states, tokens!["N", "-", "(", "N", "-", "N", ")"]).unwrap(); assert_eq!( &format!("{}", tree)[..], r#"[S: [E: [E: [T: "N"]], "-", [T: "(", [E: [E: [T: "N"]], "-", [T: "N"]], ")"]]]"# ); // incomplete: assert!(interpret(&states, tokens!["N", "-", "(", "N", "-", "N"]).is_err()); // incomplete: assert!(interpret(&states, tokens!["N", "-"]).is_err()); // unexpected character: assert!(interpret(&states, tokens!["N", "-", ")", "N", "-", "N", "("]).is_err()); // parens first: let tree = interpret(&states, tokens!["(", "N", "-", "N", ")", "-", "N"]).unwrap(); println!("{}", tree); assert_eq!( &format!("{}", tree)[..], r#"[S: [E: [E: [T: "(", [E: [E: [T: "N"]], "-", [T: "N"]], ")"]], "-", [T: "N"]]]"# ); // run some random tests random_test(&grammar, &states, nt("S")); } #[test] fn shift_reduce_conflict1() { let _tls = Tls::test(); // This grammar gets a shift-reduce conflict because if the input // is "&" (*) "L", then we see two possibilities, and we must decide // between them: // // "&" (*) "L" E // | | | // +-------+--| // | // E // // or // // "&" (*) "L" // | | // | OPT_L E // | | | // +---+---+----+ // | // E // // to some extent this may be a false conflict, in that inlined // rules would address it, but it's an interesting one for // producing a useful error message. let grammar = normalized_grammar( r#" grammar; extern { enum Tok { "L" => .., "&" => .., } } E: () = { "L", "&" OPT_L E }; OPT_L: () = { (), "L" }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); assert!(build_lr1_states(&grammar, nt("E")).is_err()); } /// One of the few grammars that IS LR(0). #[test] fn lr0_expr_grammar_with_explicit_eof() { let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; S: () = E "$"; E: () = { E "-" T, T, }; T: () = { "N", "(" E ")", }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); // for now, just test that process does not result in an error // and yields expected number of states. let states = build_lr0_states(&grammar, nt("S")).unwrap(); assert_eq!(states.len(), 10); } /// Without the artifical '$', grammar is not LR(0). #[test] fn lr0_expr_grammar_with_implicit_eof() { let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; S: () = E; E: () = { E "-" T, T, }; T: () = { "N", "(" E ")", }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); build_lr0_states(&grammar, nt("S")).unwrap_err(); } /// When we moved to storing items as (lr0 -> TokenSet) pairs, a bug /// in the transitive closure routine could cause us to have `(Foo, /// S0)` and `(Foo, S1)` as distinct items instead of `(Foo, S0|S1)`. #[test] fn issue_144() { let _tls = Tls::test(); let grammar = normalized_grammar( r##" grammar; pub ForeignItem: () = { AttrsAndVis "item_foreign_fn", AttrsAndVis "unsafe" "item_foreign_fn", }; AttrsAndVis: () = { MaybeOuterAttrs visibility, }; MaybeOuterAttrs: () = { OuterAttrs, (), }; visibility: () = { "pub", (), }; OuterAttrs: () = { OuterAttr, OuterAttrs OuterAttr, }; OuterAttr: () = { "#" "[" "]", }; Ident: () = { "IDENT", }; ty: () = { "ty" }; "##, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); build_lr1_states(&grammar, nt("ForeignItem")).unwrap(); } // Not sure if this is the right spot #[test] fn match_grammar() { let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; match { r"(?i)select" => SELECT } else { _ } pub Query = SELECT r"[a-z]+"; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let states = build_lr0_states(&grammar, nt("Query")).expect("build states"); println!("states: {:?}", states); } lalrpop-0.17.2/src/lr1/build_lalr/mod.rs000064400000000000000000000123061346406170700161750ustar0000000000000000//! Mega naive LALR(1) generation algorithm. use collections::{map, Map, Multimap}; use grammar::repr::*; use itertools::Itertools; use lr1::build; use lr1::core::*; use lr1::lookahead::*; use std::mem; use std::rc::Rc; use tls::Tls; #[cfg(test)] mod test; // Intermediate LALR(1) state. Identical to an LR(1) state, but that // the items can be pushed to. We initially create these with an empty // set of actions, as well. struct LALR1State<'grammar> { pub index: StateIndex, pub items: Vec>, pub shifts: Map, pub reductions: Multimap<&'grammar Production, TokenSet>, pub gotos: Map, } pub fn build_lalr_states<'grammar>( grammar: &'grammar Grammar, start: NonterminalString, ) -> LR1Result<'grammar> { // First build the LR(1) states let lr_states = build::build_lr1_states(grammar, start)?; // With lane table, there is no reason to do state collapse // for LALR. In fact, LALR is pointless! if build::use_lane_table() { println!("Warning: Now that the new lane-table algorithm is the default,"); println!(" #[lalr] mode has no effect and can be removed."); return Ok(lr_states); } profile! { &Tls::session(), "LALR(1) state collapse", collapse_to_lalr_states(&lr_states) } } pub fn collapse_to_lalr_states<'grammar>(lr_states: &[LR1State<'grammar>]) -> LR1Result<'grammar> { // Now compress them. This vector stores, for each state, the // LALR(1) state to which we will remap it. let mut remap: Vec<_> = (0..lr_states.len()).map(|_| StateIndex(0)).collect(); let mut lalr1_map: Map, StateIndex> = map(); let mut lalr1_states: Vec = vec![]; for (lr1_index, lr1_state) in lr_states.iter().enumerate() { let lr0_kernel: Vec<_> = lr1_state .items .vec .iter() .map(Item::to_lr0) .dedup() .collect(); let lalr1_index = *lalr1_map.entry(lr0_kernel).or_insert_with(|| { let index = StateIndex(lalr1_states.len()); lalr1_states.push(LALR1State { index, items: vec![], shifts: map(), reductions: Multimap::new(), gotos: map(), }); index }); lalr1_states[lalr1_index.0] .items .extend(lr1_state.items.vec.iter().cloned()); remap[lr1_index] = lalr1_index; } // The reduction process can leave us with multiple // overlapping LR(0) items, whose lookaheads must be // unioned. e.g. we may now have: // // X = "(" (*) ")" ["Foo"] // X = "(" (*) ")" ["Bar"] // // which we will convert to: // // X = "(" (*) ")" ["Foo", "Bar"] for lalr1_state in &mut lalr1_states { let items = mem::replace(&mut lalr1_state.items, vec![]); let items: Multimap, TokenSet> = items .into_iter() .map( |Item { production, index, lookahead, }| { (Item::lr0(production, index), lookahead) }, ) .collect(); lalr1_state.items = items .into_iter() .map(|(lr0_item, lookahead)| lr0_item.with_lookahead(lookahead)) .collect(); } // Now that items are fully built, create the actions for (lr1_index, lr1_state) in lr_states.iter().enumerate() { let lalr1_index = remap[lr1_index]; let lalr1_state = &mut lalr1_states[lalr1_index.0]; for (terminal, &lr1_state) in &lr1_state.shifts { let target_state = remap[lr1_state.0]; let prev = lalr1_state.shifts.insert(terminal.clone(), target_state); assert!(prev.unwrap_or(target_state) == target_state); } for (nt, lr1_state) in &lr1_state.gotos { let target_state = remap[lr1_state.0]; let prev = lalr1_state.gotos.insert(nt.clone(), target_state); assert!(prev.unwrap_or(target_state) == target_state); // as above } for &(ref token_set, production) in &lr1_state.reductions { lalr1_state.reductions.push(production, token_set.clone()); } } // Finally, create the new states and detect conflicts let lr1_states: Vec<_> = lalr1_states .into_iter() .map(|lr| State { index: lr.index, items: Items { vec: Rc::new(lr.items), }, shifts: lr.shifts, reductions: lr.reductions.into_iter().map(|(p, ts)| (ts, p)).collect(), gotos: lr.gotos, }) .collect(); let conflicts: Vec<_> = lr1_states .iter() .flat_map(|s| TokenSet::conflicts(s)) .collect(); if !conflicts.is_empty() { Err(TableConstructionError { states: lr1_states, conflicts, }) } else { Ok(lr1_states) } } lalrpop-0.17.2/src/lr1/build_lalr/test.rs000064400000000000000000000023631341573331700163760ustar0000000000000000use super::super::interpret::interpret; use super::build_lalr_states; use grammar::repr::*; use lr1::tls::Lr1Tls; use string_cache::DefaultAtom as Atom; use test_util::normalized_grammar; use tls::Tls; fn nt(t: &str) -> NonterminalString { NonterminalString(Atom::from(t)) } macro_rules! tokens { ($($x:expr),*) => { vec![$(TerminalString::quoted(Atom::from($x))),*] } } #[test] fn figure9_23() { let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; extern { enum Tok { "-" => .., "N" => .., "(" => .., ")" => .. } } S: () = E => (); E: () = { E "-" T => (), T => () }; T: () = { "N" => (), "(" E ")" => () }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let states = build_lalr_states(&grammar, nt("S")).unwrap(); println!("{:#?}", states); let tree = interpret(&states, tokens!["N", "-", "(", "N", "-", "N", ")"]).unwrap(); assert_eq!( &format!("{:?}", tree)[..], r#"[S: [E: [E: [T: "N"]], "-", [T: "(", [E: [E: [T: "N"]], "-", [T: "N"]], ")"]]]"# ); } lalrpop-0.17.2/src/lr1/codegen/ascent.rs000064400000000000000000001112201346406170700161610ustar0000000000000000//! A compiler from an LR(1) table to a [recursive ascent] parser. //! //! [recursive ascent]: https://en.wikipedia.org/wiki/Recursive_ascent_parser use collections::Multimap; use grammar::repr::{ Grammar, NonterminalString, Production, Symbol, TerminalString, TypeParameter, TypeRepr, Visibility, WhereClause, }; use lr1::core::*; use lr1::lookahead::Token; use lr1::state_graph::StateGraph; use rust::RustWrite; use std::io::{self, Write}; use tls::Tls; use util::{Escape, Sep}; use super::base::CodeGenerator; pub fn compile<'grammar, W: Write>( grammar: &'grammar Grammar, user_start_symbol: NonterminalString, start_symbol: NonterminalString, states: &[LR1State<'grammar>], action_module: &str, out: &mut RustWrite, ) -> io::Result<()> { let graph = StateGraph::new(&states); let mut ascent = CodeGenerator::new_ascent( grammar, user_start_symbol, start_symbol, &graph, states, action_module, out, ); ascent.write() } struct RecursiveAscent<'ascent, 'grammar> { graph: &'ascent StateGraph, /// for each state, the set of symbols that it will require for /// input state_inputs: Vec>, /// type parameters for the `Nonterminal` type nonterminal_type_params: Vec, nonterminal_where_clauses: Vec, } /// Tracks the suffix of the stack (that is, top-most elements) that any /// particular state is aware of. We break the suffix into two parts: /// optional and fixed, which always look like this: /// /// ``` /// ... A B C X Y Z /// ~~~ ~~~~~ ~~~~~ /// | | | /// | | Fixed (top of the stack) /// | | /// | Optional (will be popped after the fixed portion) /// | /// Prefix (stuff we don't know about that is also on the stack /// ``` /// /// The idea of an "optional" member is not that it may or may not be /// on the stack. The entire suffix will always be on the stack. An /// *optional* member is one that *we* may or may not *consume*. So /// the above stack suffix could occur given a state with items like: /// /// ``` /// NT1 = A B C X Y Z (*) "." /// NT2 = X Y Z (*) "," /// ``` /// /// Depending on what comes next, if we reduce NT1, we will consume /// all six symbols, but if we reduce NT2, we will only reduce three. #[derive(Copy, Clone, Debug)] struct StackSuffix<'grammar> { /// all symbols that are known to be on the stack (optional + fixed). all: &'grammar [Symbol], /// optional symbols will be consumed by *some* reductions in this /// state, but not all len_optional: usize, } impl<'grammar> StackSuffix<'grammar> { fn len(&self) -> usize { self.all.len() } /// returns the (optional, fixed) -- number of optional /// items in stack prefix and numer of fixed fn optional_fixed_lens(&self) -> (usize, usize) { (self.len_optional, self.len() - self.len_optional) } fn is_not_empty(&self) -> bool { self.len() > 0 } fn optional(&self) -> &'grammar [Symbol] { &self.all[..self.len_optional] } fn fixed(&self) -> &'grammar [Symbol] { &self.all[self.len_optional..] } } impl<'ascent, 'grammar, W: Write> CodeGenerator<'ascent, 'grammar, W, RecursiveAscent<'ascent, 'grammar>> { fn new_ascent( grammar: &'grammar Grammar, user_start_symbol: NonterminalString, start_symbol: NonterminalString, graph: &'ascent StateGraph, states: &'ascent [LR1State<'grammar>], action_module: &str, out: &'ascent mut RustWrite, ) -> Self { let (nonterminal_type_params, nonterminal_where_clauses) = Self::filter_type_parameters_and_where_clauses( grammar, grammar.types.nonterminal_types(), ); let state_inputs = states .iter() .map(|state| Self::state_input_for(state)) .collect(); CodeGenerator::new( grammar, user_start_symbol, start_symbol, states, out, false, action_module, RecursiveAscent { graph, state_inputs, nonterminal_type_params, nonterminal_where_clauses, }, ) } /// Compute the stack suffix that the state expects on entry. fn state_input_for(state: &'ascent LR1State<'grammar>) -> StackSuffix<'grammar> { let max_prefix = state.max_prefix(); let will_pop = state.will_pop(); StackSuffix { all: max_prefix, len_optional: max_prefix.len() - will_pop.len(), } } fn write(&mut self) -> io::Result<()> { self.write_parse_mod(|this| { this.write_start_fn()?; rust!(this.out, ""); this.write_return_type_defn()?; for i in 0..this.states.len() { this.write_state_fn(StateIndex(i))?; } Ok(()) }) } fn write_return_type_defn(&mut self) -> io::Result<()> { // sometimes some of the variants are not used, particularly // if we are generating multiple parsers from the same file: rust!(self.out, "#[allow(dead_code)]"); rust!( self.out, "pub enum {}Nonterminal<{}>", self.prefix, Sep(", ", &self.custom.nonterminal_type_params) ); if !self.custom.nonterminal_where_clauses.is_empty() { rust!( self.out, " where {}", Sep(", ", &self.custom.nonterminal_where_clauses) ); } rust!(self.out, " {{"); // make an enum with one variant per nonterminal; I considered // making different enums per state, but this would mean we // have to unwrap and rewrap as we pass up the stack, which // seems silly for nt in self.grammar.nonterminals.keys() { let ty = self .types .spanned_type(self.types.nonterminal_type(nt).clone()); rust!(self.out, "{}({}),", Escape(nt), ty); } rust!(self.out, "}}"); Ok(()) } // Generates a function `parse_Foo` that will parse an entire // input as `Foo`. An error is reported if the entire input is not // consumed. fn write_start_fn(&mut self) -> io::Result<()> { let phantom_data = self.phantom_data_expr(); self.start_parser_fn()?; self.define_tokens()?; self.next_token("lookahead", "tokens")?; rust!( self.out, "match {}state0({}&mut {}tokens, {}lookahead, {})? {{", self.prefix, self.grammar.user_parameter_refs(), self.prefix, self.prefix, phantom_data ); // extra tokens? rust!(self.out, "(Some({}lookahead), _) => {{", self.prefix); rust!( self.out, "Err({}lalrpop_util::ParseError::ExtraToken {{ token: {}lookahead }})", self.prefix, self.prefix ); rust!(self.out, "}}"); // otherwise, we expect to see only the goal terminal rust!( self.out, "(None, {}Nonterminal::{}((_, {}nt, _))) => {{", self.prefix, Escape(&self.start_symbol), self.prefix ); rust!(self.out, "Ok({}nt)", self.prefix); rust!(self.out, "}}"); // nothing else should be possible rust!(self.out, "_ => unreachable!(),"); rust!(self.out, "}}"); self.end_parser_fn() } /// Writes the function that corresponds to a given state. This /// function takes arguments corresponding to the stack slots of /// the LR(1) machine. It consumes tokens and handles reduces /// etc. It will return once it has popped at least one symbol off /// of the LR stack. /// /// Note that for states which have a custom kind, this function /// emits nothing at all other than a possible comment explaining /// the state. fn write_state_fn(&mut self, this_index: StateIndex) -> io::Result<()> { let this_state = &self.states[this_index.0]; let inputs = self.custom.state_inputs[this_index.0]; rust!(self.out, ""); // Leave a comment explaining what this state is. if Tls::session().emit_comments { rust!(self.out, "// State {}", this_index.0); rust!(self.out, "// AllInputs = {:?}", inputs.all); rust!(self.out, "// OptionalInputs = {:?}", inputs.optional()); rust!(self.out, "// FixedInputs = {:?}", inputs.fixed()); rust!( self.out, "// WillPushLen = {:?}", this_state.will_push().len() ); rust!(self.out, "// WillPush = {:?}", this_state.will_push()); rust!( self.out, "// WillProduce = {:?}", this_state.will_produce() ); rust!(self.out, "//"); for item in this_state.items.vec.iter() { rust!(self.out, "// {:?}", item); } rust!(self.out, "//"); for (terminal, action) in &this_state.shifts { rust!(self.out, "// {:?} -> {:?}", terminal, action); } for &(ref tokens, action) in &this_state.reductions { rust!(self.out, "// {:?} -> {:?}", tokens, action); } rust!(self.out, "//"); for (nt, state) in &this_state.gotos { rust!(self.out, "// {:?} -> {:?}", nt, state); } } self.emit_state_fn_header("state", this_index.0, inputs)?; // possibly move some fixed inputs into optional stack slots let stack_suffix = self.adjust_inputs(this_index, inputs)?; // set to true if goto actions are worth generating let mut fallthrough = false; rust!(self.out, "match {}lookahead {{", self.prefix); // first emit shifts: for (terminal, &next_index) in &this_state.shifts { let sym_name = format!("{}sym{}", self.prefix, inputs.len()); self.consume_terminal(terminal, sym_name)?; // transition to the new state if self.transition("result", stack_suffix, next_index, &["tokens"])? { fallthrough = true; } rust!(self.out, "}}"); } // now emit reduces. It frequently happens that many tokens // trigger the same reduction, so group these by the // production that we are going to be reducing. let reductions: Multimap<_, Vec<_>> = this_state .reductions .iter() .flat_map(|&(ref tokens, production)| tokens.iter().map(move |t| (production, t))) .collect(); for (production, tokens) in reductions { for (index, token) in tokens.iter().enumerate() { let pattern = match *token { Token::Terminal(ref s) => format!("Some({})", self.match_terminal_pattern(s)), Token::Error => { panic!("Error recovery is not implemented for recursive ascent parsers") } Token::EOF => "None".to_string(), }; if index < tokens.len() - 1 { rust!(self.out, "{} |", pattern); } else { rust!(self.out, "{} => {{", pattern); } } self.emit_reduce_action("result", stack_suffix, production)?; if !production.symbols.is_empty() { // if we popped anything off of the stack, then this frame is done rust!(self.out, "return Ok({}result);", self.prefix); } else { fallthrough = true; } rust!(self.out, "}}"); } // if we hit this, the next token is not recognized, so generate an error rust!(self.out, "_ => {{"); // The terminals which would have resulted in a successful parse in this state let successful_terminals = self.grammar.terminals.all.iter().filter(|&terminal| { this_state.shifts.contains_key(terminal) || this_state .reductions .iter() .any(|&(ref t, _)| t.contains(&Token::Terminal(terminal.clone()))) }); rust!(self.out, "let {}expected = vec![", self.prefix); for terminal in successful_terminals { rust!(self.out, "r###\"{}\"###.to_string(),", terminal); } rust!(self.out, "];"); // check if we've found an unrecognized token or EOF rust!(self.out, "return Err("); rust!(self.out, "match {}lookahead {{", self.prefix); rust!(self.out, "Some({}token) => {{", self.prefix); rust!( self.out, "{}lalrpop_util::ParseError::UnrecognizedToken {{", self.prefix ); rust!(self.out, "token: {}token,", self.prefix); rust!(self.out, "expected: {}expected,", self.prefix); rust!(self.out, "}}"); rust!(self.out, "}}"); rust!(self.out, "None => {{"); // find the location of the last symbol on stack let (optional, fixed) = stack_suffix.optional_fixed_lens(); if fixed > 0 { rust!( self.out, "let {}location = {}sym{}.2.clone();", self.prefix, self.prefix, stack_suffix.len() - 1 ); } else if optional > 0 { rust!(self.out, "let {}location = ", self.prefix); for index in (0..optional).rev() { rust!( self.out, "{}sym{}.as_ref().map(|sym| sym.2.clone()).unwrap_or_else(|| {{", self.prefix, index ); } rust!(self.out, "Default::default()"); for _ in 0..optional { rust!(self.out, "}})"); } rust!(self.out, ";"); } else { rust!( self.out, "let {}location = Default::default();", self.prefix ); } rust!( self.out, "{}lalrpop_util::ParseError::UnrecognizedEOF {{", self.prefix ); rust!(self.out, "location: {}location,", self.prefix); rust!(self.out, "expected: {}expected,", self.prefix); rust!(self.out, "}}"); rust!(self.out, "}}"); rust!(self.out, "}}"); // Error match rust!(self.out, ")"); rust!(self.out, "}}"); // Wildcard match case rust!(self.out, "}}"); // match // finally, emit gotos (if relevant) if fallthrough && !this_state.gotos.is_empty() { rust!(self.out, "loop {{"); // In most states, we know precisely when the top stack // slot will be consumed (basically, when we reduce or // when we transition to another state). But in some states, // we may not know. Consider: // // X = A (*) "0" ["."] // X = A (*) B ["."] // B = (*) "0" "1" ["."] // // Now if we see a `"0"` this *could* be the start of a `B // = "0" "1"` or it could be the continuation of `X = A // "0"`. We won't know until we see the *next* character // (which will either be `"0"` or `"."`). If it turns out to be // `X = A "0"`, then the state handling the `"0"` will reduce // and consume the `A` and the `"0"`. But otherwise it will shift // the `"1"` and leave the `A` unprocessed. // // In cases like this, the `adjust_inputs` routine will // have taken the top of the stack ("A") and put it into // an `Option`. After the state processing the `"0"` // returns then, we can check this option to see whether // it has popped the `"A"` (in which case we ought to // return) or not (in which case we ought to shift the `B` // value that it returned to us). let top_slot_optional = { stack_suffix.is_not_empty() && stack_suffix.fixed().is_empty() }; if top_slot_optional { rust!( self.out, "if {}sym{}.is_none() {{", self.prefix, stack_suffix.len() - 1 ); rust!(self.out, "return Ok({}result);", self.prefix); rust!(self.out, "}}"); } rust!( self.out, "let ({}lookahead, {}nt) = {}result;", self.prefix, self.prefix, self.prefix ); rust!(self.out, "match {}nt {{", self.prefix); for (ref nt, &next_index) in &this_state.gotos { // The nonterminal we are shifting becomes symN, where // N is the number of inputs to this state (which are // numbered sym0..sym(N-1)). It is never optional // because we always transition to a state with at // least *one* fixed input. rust!( self.out, "{}Nonterminal::{}({}sym{}) => {{", self.prefix, Escape(nt), self.prefix, stack_suffix.len() ); self.transition("result", stack_suffix, next_index, &["tokens", "lookahead"])?; rust!(self.out, "}}"); } // Errors are not possible in the goto phase; a missing entry // indicates parse successfully completed, so just bail out. if this_state.gotos.len() != self.grammar.nonterminals.keys().len() { rust!(self.out, "_ => {{"); rust!( self.out, "return Ok(({}lookahead, {}nt));", self.prefix, self.prefix ); rust!(self.out, "}}"); } rust!(self.out, "}}"); // match rust!(self.out, "}}"); // while/loop } else if fallthrough { rust!(self.out, "return Ok({}result);", self.prefix); } rust!(self.out, "}}"); // fn Ok(()) } fn emit_state_fn_header( &mut self, fn_kind: &str, // e.g. "state", "custom" fn_index: usize, // state index, custom kind index, etc suffix: StackSuffix<'grammar>, ) -> io::Result<()> { let optional_prefix = suffix.optional(); let fixed_prefix = suffix.fixed(); let triple_type = self.triple_type(); let parse_error_type = self.types.parse_error_type(); let (fn_args, starts_with_terminal) = self.fn_args(optional_prefix, fixed_prefix); self.out .fn_header( &Visibility::Priv, format!("{}{}{}", self.prefix, fn_kind, fn_index), ) .with_grammar(self.grammar) .with_type_parameters(Some(format!( "{}TOKENS: Iterator>", self.prefix, triple_type, parse_error_type ))) .with_parameters(fn_args) .with_return_type(format!( "Result<(Option<{}>, {}Nonterminal<{}>), {}>", triple_type, self.prefix, Sep(", ", &self.custom.nonterminal_type_params), parse_error_type )) .emit()?; rust!(self.out, "{{"); rust!( self.out, "let mut {}result: (Option<{}>, {}Nonterminal<{}>);", self.prefix, triple_type, self.prefix, Sep(", ", &self.custom.nonterminal_type_params) ); // shift lookahead is necessary; see `starts_with_terminal` above if starts_with_terminal { self.next_token("lookahead", "tokens")?; } Ok(()) } // Compute the set of arguments that the function for a state or // custom-kind expects. The argument `symbols` represents the top // portion of the stack which this function expects to be given. // Each of them will be given an argument like `sym3: &mut // Option` where `Sym3` is the type of the symbol. // // Returns a list of argument names and a flag if this fn resulted // from pushing a terminal (in which case the lookahead must be // computed interally). fn fn_args( &mut self, optional_prefix: &[Symbol], fixed_prefix: &[Symbol], ) -> (Vec, bool) { assert!( // start state: (optional_prefix.is_empty() && fixed_prefix.is_empty()) || /* any other state: */ !fixed_prefix.is_empty() ); let triple_type = self.triple_type(); // to reduce the size of the generated code, if the state // results from shifting a terminal, then we do not pass the // lookahead in as an argument, but rather we load it as the // first thing in this function; this saves some space because // there are more edges than there are states in the graph. let starts_with_terminal = fixed_prefix .last() .map(Symbol::is_terminal) .unwrap_or(false); let mut base_args = vec![format!("{}tokens: &mut {}TOKENS", self.prefix, self.prefix)]; if !starts_with_terminal { base_args.push(format!("{}lookahead: Option<{}>", self.prefix, triple_type)); } // "Optional symbols" may or may not be consumed, so take an // `&mut Option` let optional_args = (0..optional_prefix.len()).map(|i| { format!( "{}sym{}: &mut Option<{}>", self.prefix, i, self.types .spanned_type(optional_prefix[i].ty(&self.types).clone()) ) }); // "Fixed symbols" will be consumed before we return, so take the value itself let fixed_args = (0..fixed_prefix.len()).map(|i| { format!( "{}sym{}: {}", self.prefix, optional_prefix.len() + i, self.types .spanned_type(fixed_prefix[i].ty(&self.types).clone()) ) }); let all_args = base_args .into_iter() .chain(optional_args) .chain(fixed_args) .chain(Some(format!("_: {}", self.phantom_data_type()))) .collect(); (all_args, starts_with_terminal) } /// Examine the states that we may transition to. Unless this is /// the start state, we will always take at least 1 fixed input: /// the most recently pushed symbol (let's call it `symX`), and we /// may have others as well. But if this state can transition to /// another state can takes some of those inputs as optional /// parameters, we need to convert them them options. This /// function thus emits code to move each sum `symX` into an /// option, and returns an adjusted stack-suffix that reflects the /// changes made. fn adjust_inputs( &mut self, state_index: StateIndex, inputs: StackSuffix<'grammar>, ) -> io::Result> { let mut result = inputs; let top_opt = self .custom .graph .successors(state_index) .iter() .any(|succ_state| { let succ_inputs = &self.custom.state_inputs[succ_state.0]; // Check for a successor state with a suffix like: // // ... OPT_1 ... OPT_N FIXED_1 // // (Remember that *every* successor state will have // at least one fixed input.) // // So basically we are looking for states // that, when they return, may *optionally* have consumed // the top of our stack. assert!(!succ_inputs.fixed().is_empty()); succ_inputs.fixed().len() == 1 && !succ_inputs.optional().is_empty() }); // If we find a successor that may optionally consume the top // of our stack, convert our fixed inputs into optional ones. // // (Here we convert *all* fixed inputs. Honestly, I can't // remember if this is necessary, or just for simplicity. I // suspect the latter. --nmatsakis) if top_opt { let start_num = inputs.optional().len(); for sym_num in (start_num..start_num + inputs.fixed().len()) { rust!( self.out, "let {}sym{} = &mut Some({}sym{});", self.prefix, sym_num, self.prefix, sym_num ); } result.len_optional = result.len(); } Ok(result) } /// Given that we have, locally, `optional` number of optional stack slots /// followed by `fixed` number of fixed stack slots, prepare the inputs /// to be supplied to `inputs`. Returns a string of names for this inputs. fn pop_syms( &mut self, optional: usize, fixed: usize, inputs: StackSuffix<'grammar>, ) -> io::Result> { let total_have = optional + fixed; let total_need = inputs.len(); (total_have - total_need..total_have) // number relative to us .zip(0..total_need) // number relative to them .map(|(h, n)| { let name = format!("{}sym{}", self.prefix, h); let have_optional = h < optional; let need_optional = n < inputs.len_optional; // if we have something stored in an `Option`, but the next state // consumes it unconditionally, then "pop" it if have_optional && !need_optional { rust!(self.out, "let {} = {}.take().unwrap();", name, name); } else { // we should never have something stored // unconditionally that the next state only // "maybe" consumes -- we should have fixed this // in the `adjust_inputs` phase assert_eq!(have_optional, need_optional); } Ok(name) }) .collect() } /// Emit code to shift/goto into the state `next_index`. Returns /// `true` if the current state may be valid after the target /// state returns, or `false` if `transition` will just return /// afterwards. /// /// # Arguments /// /// - `into_result`: name of variable to store result from target state into /// - `stack_suffix`: the suffix of the LR stack that current state is aware of, /// and how it is distributed into optional/fixed slots /// - `next_index`: target state /// - `other_args`: other arguments we are threading along fn transition( &mut self, into_result: &str, stack_suffix: StackSuffix<'grammar>, next_index: StateIndex, other_args: &[&str], ) -> io::Result { // the depth of the suffix of the stack that we are aware of // in the current state, including the newly shifted token let (optional, mut fixed) = stack_suffix.optional_fixed_lens(); fixed += 1; // we just shifted another symbol let total = optional + fixed; assert!(total == stack_suffix.len() + 1); // symbols that the next state expects; will always be include // at least one fixed input let next_inputs = self.custom.state_inputs[next_index.0]; assert!(!next_inputs.fixed().is_empty()); assert!(next_inputs.len() <= total); let transfer_syms = self.pop_syms(optional, fixed, next_inputs)?; let other_args = other_args .iter() .map(|s| format!("{}{}", self.prefix, s)) .collect(); let fn_name = format!("{}state{}", self.prefix, next_index.0); // invoke next state, transferring the top `m` tokens let phantom_data_expr = self.phantom_data_expr(); rust!( self.out, "{}{} = {}({}{}, {}, {})?;", self.prefix, into_result, fn_name, self.grammar.user_parameter_refs(), Sep(", ", &other_args), Sep(", ", &transfer_syms), phantom_data_expr ); // if the target state takes at least **two** fixed tokens, // then it will have consumed the top of **our** stack frame, // so we should just return if next_inputs.fixed().len() >= 2 { rust!(self.out, "return Ok({}{});", self.prefix, into_result); Ok(false) } else { Ok(true) } } /// Executes a reduction of `production`, storing the result into /// the variable `into_var`, which should have type /// `(Option<(L,T,L)>, Nonterminal)`. fn emit_reduce_action( &mut self, into_var: &str, stack_suffix: StackSuffix<'grammar>, production: &'grammar Production, ) -> io::Result<()> { let loc_type = self.types.terminal_loc_type(); let (optional, fixed) = stack_suffix.optional_fixed_lens(); let production_inputs = StackSuffix { all: &production.symbols, len_optional: 0, }; let transfer_syms = self.pop_syms(optional, fixed, production_inputs)?; // identify the "start" location for this production; this // is typically the start of the first symbol we are // reducing; but in the case of an empty production, it // will be the last symbol pushed, or at worst `default`. if let Some(first_sym) = transfer_syms.first() { rust!( self.out, "let {}start = {}.0.clone();", self.prefix, first_sym ); } else if stack_suffix.len() > 0 { // we pop no symbols, so grab from the top of the stack // (unless we are in the start state) let top = stack_suffix.len() - 1; if !stack_suffix.fixed().is_empty() { rust!( self.out, "let {}start = {}sym{}.2.clone();", self.prefix, self.prefix, top ); } else { // top of stack is optional; should not have been popped yet tho rust!( self.out, "let {}start = {}sym{}.as_ref().unwrap().2.clone();", self.prefix, self.prefix, top ); } } else { // this only occurs in the start state rust!( self.out, "let {}start: {} = ::std::default::Default::default();", self.prefix, loc_type ); } // identify the "end" location for this production; // this is typically the end of the last symbol we are reducing, // but in the case of an empty production it will come from the // lookahead if let Some(last_sym) = transfer_syms.last() { rust!(self.out, "let {}end = {}.2.clone();", self.prefix, last_sym); } else { rust!( self.out, "let {}end = {}lookahead.as_ref().map(|o| o.0.clone()).unwrap_or_else(|| \ {}start.clone());", self.prefix, self.prefix, self.prefix ); } let transfered_syms = transfer_syms.len(); let mut args = transfer_syms; if transfered_syms == 0 { args.push(format!("&{}start", self.prefix)); args.push(format!("&{}end", self.prefix)); } // invoke the action code let is_fallible = self.grammar.action_is_fallible(production.action); if is_fallible { rust!( self.out, "let {}nt = {}::{}action{}::<{}>({}{})?;", self.prefix, self.action_module, self.prefix, production.action.index(), Sep(", ", &self.grammar.non_lifetime_type_parameters()), self.grammar.user_parameter_refs(), Sep(", ", &args) ) } else { rust!( self.out, "let {}nt = {}::{}action{}::<{}>({}{});", self.prefix, self.action_module, self.prefix, production.action.index(), Sep(", ", &self.grammar.non_lifetime_type_parameters()), self.grammar.user_parameter_refs(), Sep(", ", &args) ) } // wrap up the produced value into `Nonterminal` along with rust!( self.out, "let {}nt = {}Nonterminal::{}((", self.prefix, self.prefix, Escape(&production.nonterminal) ); rust!(self.out, "{}start,", self.prefix); rust!(self.out, "{}nt,", self.prefix); rust!(self.out, "{}end,", self.prefix); rust!(self.out, "));"); // wrap up the result along with the (unused) lookahead rust!( self.out, "{}{} = ({}lookahead, {}nt);", self.prefix, into_var, self.prefix, self.prefix ); Ok(()) } /// Emit a pattern that matches `id` but doesn't extract any data. fn match_terminal_pattern(&mut self, id: &TerminalString) -> String { let pattern = self.grammar.pattern(id).map(&mut |_| "_"); let pattern = format!("{}", pattern); format!("(_, {}, _)", pattern) } /// Emit a pattern that matches `id` and extracts its value, storing /// that value as `let_name`. fn consume_terminal(&mut self, id: &TerminalString, let_name: String) -> io::Result<()> { let mut pattern_names = vec![]; let pattern = self.grammar.pattern(id).map(&mut |_| { let index = pattern_names.len(); pattern_names.push(format!("{}tok{}", self.prefix, index)); pattern_names.last().cloned().unwrap() }); let mut pattern = format!("{}", pattern); if pattern_names.is_empty() { pattern_names.push(format!("{}tok", self.prefix)); pattern = format!("{}tok @ {}", self.prefix, pattern); } pattern = format!("({}loc1, {}, {}loc2)", self.prefix, pattern, self.prefix); rust!(self.out, "Some({}) => {{", pattern); rust!( self.out, "let {} = ({}loc1, ({}), {}loc2);", let_name, self.prefix, pattern_names.join(", "), self.prefix ); Ok(()) } fn triple_type(&self) -> TypeRepr { self.types.triple_type() } fn next_token(&mut self, lookahead: &str, tokens: &str) -> io::Result<()> { rust!( self.out, "let {}{} = match {}{}.next() {{", self.prefix, lookahead, self.prefix, tokens ); rust!(self.out, "Some(Ok(v)) => Some(v),"); rust!(self.out, "Some(Err(e)) => return Err(e),"); rust!(self.out, "None => None,"); rust!(self.out, "}};"); Ok(()) } } lalrpop-0.17.2/src/lr1/codegen/base.rs000064400000000000000000000322301346406170700156210ustar0000000000000000//! Base helper routines for a code generator. use collections::Set; use grammar::free_variables::FreeVariables; use grammar::repr::*; use lr1::core::*; use rust::RustWrite; use std::io::{self, Write}; use util::Sep; /// Base struct for various kinds of code generator. The flavor of /// code generator is customized by supplying distinct types for `C` /// (e.g., `self::ascent::RecursiveAscent`). pub struct CodeGenerator<'codegen, 'grammar: 'codegen, W: Write + 'codegen, C> { /// the complete grammar pub grammar: &'grammar Grammar, /// some suitable prefix to separate our identifiers from the user's pub prefix: &'grammar str, /// types from the grammar pub types: &'grammar Types, /// the start symbol S the user specified pub user_start_symbol: NonterminalString, /// the synthetic start symbol S' that we specified pub start_symbol: NonterminalString, /// the vector of states pub states: &'codegen [LR1State<'grammar>], /// where we write output pub out: &'codegen mut RustWrite, /// where to find the action routines (typically `super`) pub action_module: String, /// custom fields for the specific kind of codegenerator /// (recursive ascent, table-driven, etc) pub custom: C, pub repeatable: bool, } impl<'codegen, 'grammar, W: Write, C> CodeGenerator<'codegen, 'grammar, W, C> { pub fn new( grammar: &'grammar Grammar, user_start_symbol: NonterminalString, start_symbol: NonterminalString, states: &'codegen [LR1State<'grammar>], out: &'codegen mut RustWrite, repeatable: bool, action_module: &str, custom: C, ) -> Self { CodeGenerator { grammar, prefix: &grammar.prefix, types: &grammar.types, states, user_start_symbol, start_symbol, out, custom, repeatable, action_module: action_module.to_string(), } } /// We often create meta types that pull together a bunch of /// user-given types -- basically describing (e.g.) the full set /// of return values from any nonterminal (and, in some cases, /// terminals). These types need to carry generic parameters from /// the grammar, since the nonterminals may include generic /// parameters -- but we don't want them to carry *all* the /// generic parameters, since that can be unnecessarily /// restrictive. /// /// In particular, consider something like this: /// /// ```notrust /// grammar<'a>(buffer: &'a mut Vec); /// ``` /// /// Here, we likely do not want the `'a` in the type of `buffer` to appear /// in the nonterminal result. That's because, if it did, then the /// action functions will have a signature like: /// /// ```ignore /// fn foo<'a, T>(x: &'a mut Vec) -> Result<'a> { ... } /// ``` /// /// In that case, we would only be able to call one action fn and /// will in fact get borrowck errors, because Rust would think we /// were potentially returning this `&'a mut Vec`. /// /// Therefore, we take the full list of type parameters and we /// filter them down to those that appear in the types that we /// need to include (those that appear in the `tys` parameter). /// /// In some cases, we need to include a few more than just that /// obviously appear textually: for example, if we have `T::Foo`, /// and we see a where-clause `T: Bar<'a>`, then we need to /// include both `T` and `'a`, since that bound may be important /// for resolving `T::Foo` (in other words, `T::Foo` may expand to /// `>::Foo`). pub fn filter_type_parameters_and_where_clauses( grammar: &Grammar, tys: impl IntoIterator, ) -> (Vec, Vec) { let referenced_ty_params: Set<_> = tys .into_iter() .flat_map(|t| t.free_variables(&grammar.type_parameters)) .collect(); let filtered_type_params: Vec<_> = grammar .type_parameters .iter() .filter(|t| referenced_ty_params.contains(t)) .cloned() .collect(); // If `T` is referenced in the types we need to keep, then // include any bounds like `T: Foo`. This may be needed for // the well-formedness conditions on `T` (e.g., maybe we have // `T: Hash` and a `HashSet` or something) but it may also // be needed because of `T::Foo`-like types. // // Do not however include a bound like `T: 'a` unless both `T` // **and** `'a` are referenced -- same with bounds like `T: // Foo`. If those were needed, then `'a` or `U` would also // have to appear in the types. debug!("filtered_type_params = {:?}", filtered_type_params); let filtered_where_clauses: Vec<_> = grammar .where_clauses .iter() .filter(|wc| { debug!( "wc = {:?} free_variables = {:?}", wc, wc.free_variables(&grammar.type_parameters) ); wc.free_variables(&grammar.type_parameters) .iter() .all(|p| referenced_ty_params.contains(p)) }) .cloned() .collect(); debug!("filtered_where_clauses = {:?}", filtered_where_clauses); (filtered_type_params, filtered_where_clauses) } pub fn write_parse_mod(&mut self, body: F) -> io::Result<()> where F: FnOnce(&mut Self) -> io::Result<()>, { rust!(self.out, ""); rust!(self.out, "#[cfg_attr(rustfmt, rustfmt_skip)]"); rust!(self.out, "mod {}parse{} {{", self.prefix, self.start_symbol); // these stylistic lints are annoying for the generated code, // which doesn't follow conventions: rust!( self.out, "#![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, \ unused_imports, unused_parens)]" ); rust!(self.out, ""); self.write_uses()?; body(self)?; rust!(self.out, "}}"); Ok(()) } pub fn write_uses(&mut self) -> io::Result<()> { self.out .write_uses(&format!("{}::", self.action_module), &self.grammar)?; if self.grammar.intern_token.is_some() { rust!( self.out, "use {}::{}intern_token::Token;", self.action_module, self.prefix ); } else { rust!( self.out, "use {}::{}ToTriple;", self.action_module, self.prefix ); } Ok(()) } pub fn start_parser_fn(&mut self) -> io::Result<()> { let parse_error_type = self.types.parse_error_type(); let (type_parameters, parameters, mut where_clauses); let intern_token = self.grammar.intern_token.is_some(); if intern_token { // if we are generating the tokenizer, we just need the // input, and that has already been added as one of the // user parameters type_parameters = vec![]; parameters = vec![]; where_clauses = vec![]; } else { // otherwise, we need an iterator of type `TOKENS` let mut user_type_parameters = String::new(); for type_parameter in &self.grammar.type_parameters { user_type_parameters.push_str(&format!("{}, ", type_parameter)); } type_parameters = vec![ format!( "{}TOKEN: {}ToTriple<{}>", self.prefix, self.prefix, user_type_parameters, ), format!( "{}TOKENS: IntoIterator", self.prefix, self.prefix ), ]; parameters = vec![format!("{}tokens0: {}TOKENS", self.prefix, self.prefix)]; where_clauses = vec![]; if self.repeatable { where_clauses.push(format!("{}TOKENS: Clone", self.prefix)); } } rust!( self.out, "{}struct {}Parser {{", self.grammar.nonterminals[&self.start_symbol].visibility, self.user_start_symbol ); if intern_token { rust!( self.out, "builder: {1}::{0}intern_token::{0}MatcherBuilder,", self.prefix, self.action_module ); } rust!(self.out, "_priv: (),"); rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "impl {}Parser {{", self.user_start_symbol); rust!( self.out, "{}fn new() -> {}Parser {{", self.grammar.nonterminals[&self.start_symbol].visibility, self.user_start_symbol ); if intern_token { rust!( self.out, "let {0}builder = {1}::{0}intern_token::{0}MatcherBuilder::new();", self.prefix, self.action_module ); } rust!(self.out, "{}Parser {{", self.user_start_symbol); if intern_token { rust!(self.out, "builder: {}builder,", self.prefix); } rust!(self.out, "_priv: (),"); rust!(self.out, "}}"); // Parser rust!(self.out, "}}"); // new() rust!(self.out, ""); rust!(self.out, "#[allow(dead_code)]"); self.out .fn_header( &self.grammar.nonterminals[&self.start_symbol].visibility, "parse".to_owned(), ) .with_parameters(Some("&self".to_owned())) .with_grammar(self.grammar) .with_type_parameters(type_parameters) .with_parameters(parameters) .with_return_type(format!( "Result<{}, {}>", self.types.nonterminal_type(&self.start_symbol), parse_error_type )) .with_where_clauses(where_clauses) .emit()?; rust!(self.out, "{{"); Ok(()) } pub fn define_tokens(&mut self) -> io::Result<()> { if self.grammar.intern_token.is_some() { // if we are generating the tokenizer, create a matcher as our input iterator rust!( self.out, "let mut {}tokens = self.builder.matcher(input);", self.prefix ); } else { // otherwise, convert one from the `IntoIterator` // supplied, using the `ToTriple` trait which inserts // errors/locations etc if none are given let clone_call = if self.repeatable { ".clone()" } else { "" }; rust!( self.out, "let {}tokens = {}tokens0{}.into_iter();", self.prefix, self.prefix, clone_call ); rust!( self.out, "let mut {}tokens = {}tokens.map(|t| {}ToTriple::to_triple(t));", self.prefix, self.prefix, self.prefix ); } Ok(()) } pub fn end_parser_fn(&mut self) -> io::Result<()> { rust!(self.out, "}}"); // fn rust!(self.out, "}}"); // impl Ok(()) } /// Returns phantom data type that captures the user-declared type /// parameters in a phantom-data. This helps with ensuring that /// all type parameters are constrained, even if they are not /// used. pub fn phantom_data_type(&self) -> String { let phantom_bits: Vec<_> = self .grammar .type_parameters .iter() .map(|tp| match *tp { TypeParameter::Lifetime(ref l) => format!("&{} ()", l), TypeParameter::Id(ref id) => id.to_string(), }) .collect(); format!("::std::marker::PhantomData<({})>", Sep(", ", &phantom_bits),) } /// Returns expression that captures the user-declared type /// parameters in a phantom-data. This helps with ensuring that /// all type parameters are constrained, even if they are not /// used. pub fn phantom_data_expr(&self) -> String { let phantom_bits: Vec<_> = self .grammar .type_parameters .iter() .map(|tp| match *tp { TypeParameter::Lifetime(_) => "&()".to_string(), TypeParameter::Id(ref id) => id.to_string(), }) .collect(); format!( "::std::marker::PhantomData::<({})>", Sep(", ", &phantom_bits), ) } } lalrpop-0.17.2/src/lr1/codegen/mod.rs000064400000000000000000000001051326645251200154600ustar0000000000000000pub mod ascent; mod base; pub mod parse_table; pub mod test_all; lalrpop-0.17.2/src/lr1/codegen/parse_table.rs000064400000000000000000001413211346406170700171720ustar0000000000000000//! A compiler from an LR(1) table to a traditional table driven parser. use collections::{Entry, Map, Set}; use grammar::repr::*; use lr1::core::*; use lr1::lookahead::Token; use rust::RustWrite; use std::fmt; use std::io::{self, Write}; use std::rc::Rc; use string_cache::DefaultAtom as Atom; use tls::Tls; use util::Sep; use super::base::CodeGenerator; const DEBUG_PRINT: bool = false; pub fn compile<'grammar, W: Write>( grammar: &'grammar Grammar, user_start_symbol: NonterminalString, start_symbol: NonterminalString, states: &[LR1State<'grammar>], action_module: &str, out: &mut RustWrite, ) -> io::Result<()> { let mut table_driven = CodeGenerator::new_table_driven( grammar, user_start_symbol, start_symbol, states, action_module, out, ); table_driven.write() } enum Comment<'a, T> { Goto(T, usize), Error(T), Reduce(T, &'a Production), } impl<'a, T: fmt::Display> fmt::Display for Comment<'a, T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { Comment::Goto(ref token, new_state) => { write!(f, " // on {}, goto {}", token, new_state) } Comment::Error(ref token) => write!(f, " // on {}, error", token), Comment::Reduce(ref token, production) => { write!(f, " // on {}, reduce `{:?}`", token, production) } } } } struct TableDriven<'grammar> { /// type parameters for the `Nonterminal` type symbol_type_params: Vec, symbol_where_clauses: Vec, machine: Rc, /// a list of each nonterminal in some specific order all_nonterminals: Vec, reduce_indices: Map<&'grammar Production, usize>, state_type: &'static str, variant_names: Map, variants: Map, reduce_functions: Set, } impl<'ascent, 'grammar, W: Write> CodeGenerator<'ascent, 'grammar, W, TableDriven<'grammar>> { fn new_table_driven( grammar: &'grammar Grammar, user_start_symbol: NonterminalString, start_symbol: NonterminalString, states: &'ascent [LR1State<'grammar>], action_module: &str, out: &'ascent mut RustWrite, ) -> Self { let (symbol_type_params, symbol_where_clauses) = Self::filter_type_parameters_and_where_clauses( grammar, grammar .types .nonterminal_types() .into_iter() .chain(grammar.types.terminal_types()), ); let machine = Rc::new(MachineParameters::new(grammar)); // Assign each production a unique index to use as the values for reduce // actions in the ACTION and EOF_ACTION tables. let reduce_indices: Map<&'grammar Production, usize> = grammar .nonterminals .values() .flat_map(|nt| &nt.productions) .zip(0..) .collect(); let state_type = { // `reduce_indices` are allowed to be +1 since the negative maximum of any integer type // is one larger than the positive maximum let max_value = ::std::cmp::max(states.len(), reduce_indices.len()); if max_value <= ::std::i8::MAX as usize { "i8" } else if max_value <= ::std::i16::MAX as usize { "i16" } else { "i32" } }; CodeGenerator::new( grammar, user_start_symbol, start_symbol, states, out, false, action_module, TableDriven { symbol_type_params, symbol_where_clauses, machine, all_nonterminals: grammar.nonterminals.keys().cloned().collect(), reduce_indices, state_type, variant_names: Map::new(), variants: Map::new(), reduce_functions: Set::new(), }, ) } fn write(&mut self) -> io::Result<()> { self.write_parse_mod(|this| { this.write_value_type_defn()?; this.write_parse_table()?; this.write_machine_definition()?; this.write_token_to_integer_fn()?; this.write_token_to_symbol_fn()?; this.write_simulate_reduce_fn()?; this.write_parser_fn()?; this.write_accepts_fn()?; this.emit_reduce_actions()?; this.emit_downcast_fns()?; this.emit_reduce_action_functions()?; Ok(()) }) } fn write_machine_definition(&mut self) -> io::Result<()> { let error_type = self.types.error_type(); let token_type = self.types.terminal_token_type(); let loc_type = self.types.terminal_loc_type(); let start_type = self.types.nonterminal_type(&self.start_symbol); let state_type = self.custom.state_type; let symbol_type = self.symbol_type(); let phantom_data_type = self.phantom_data_type(); let phantom_data_expr = self.phantom_data_expr(); let machine = self.custom.machine.clone(); let machine_type_parameters = Sep(", ", &machine.type_parameters); let machine_where_clauses = Sep(", ", &machine.where_clauses); rust!( self.out, "pub struct {p}StateMachine<{mtp}>", p = self.prefix, mtp = machine_type_parameters, ); rust!(self.out, "where {mwc}", mwc = machine_where_clauses); rust!(self.out, "{{"); for param in &machine.fields { rust!(self.out, "{name}: {ty},", name = param.name, ty = param.ty,); } rust!( self.out, "{p}phantom: {phantom},", p = self.prefix, phantom = phantom_data_type, ); rust!(self.out, "}}"); rust!( self.out, "impl<{mtp}> {p}state_machine::ParserDefinition for {p}StateMachine<{mtp}>", p = self.prefix, mtp = machine_type_parameters, ); rust!(self.out, "where {mwc}", mwc = machine_where_clauses); rust!(self.out, "{{"); rust!(self.out, "type Location = {t};", t = loc_type); rust!(self.out, "type Error = {t};", t = error_type); rust!(self.out, "type Token = {t};", t = token_type); rust!(self.out, "type TokenIndex = usize;"); rust!( self.out, "type Symbol = {symbol_type};", symbol_type = symbol_type, ); rust!(self.out, "type Success = {t};", t = start_type); rust!(self.out, "type StateIndex = {t};", t = state_type); rust!(self.out, "type Action = {t};", t = state_type); rust!(self.out, "type ReduceIndex = {t};", t = state_type); rust!(self.out, "type NonterminalIndex = usize;"); rust!(self.out, ""); rust!(self.out, "#[inline]"); rust!(self.out, "fn start_location(&self) -> Self::Location {{"); rust!(self.out, " Default::default()"); rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "#[inline]"); rust!(self.out, "fn start_state(&self) -> Self::StateIndex {{"); rust!(self.out, " 0"); rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "#[inline]"); rust!( self.out, "fn token_to_index(&self, token: &Self::Token) -> Option {{" ); rust!( self.out, "{p}token_to_integer(token, {phantom})", p = self.prefix, phantom = phantom_data_expr, ); rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "#[inline]"); rust!( self.out, "fn action(&self, state: {state_type}, integer: usize) -> {state_type} {{", state_type = state_type ); rust!( self.out, "{p}ACTION[(state as usize) * {num_term} + integer]", p = self.prefix, num_term = self.grammar.terminals.all.len(), ); rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "#[inline]"); rust!( self.out, "fn error_action(&self, state: {state_type}) -> {state_type} {{", state_type = state_type, ); rust!( self.out, "{p}ACTION[(state as usize) * {num_term} + ({num_term} - 1)]", p = self.prefix, num_term = self.grammar.terminals.all.len(), ); rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "#[inline]"); rust!( self.out, "fn eof_action(&self, state: {state_type}) -> {state_type} {{", state_type = state_type, ); rust!(self.out, "{p}EOF_ACTION[state as usize]", p = self.prefix,); rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "#[inline]"); rust!( self.out, "fn goto(&self, state: {state_type}, nt: usize) -> {state_type} {{", state_type = state_type, ); rust!( self.out, "{p}GOTO[(state as usize) * {num_non_term} + nt] - 1", p = self.prefix, num_non_term = self.grammar.nonterminals.len(), ); rust!(self.out, "}}"); rust!(self.out, ""); rust!( self.out, "fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol {{" ); rust!( self.out, "{p}token_to_symbol(token_index, token, {phantom})", p = self.prefix, phantom = phantom_data_expr, ); rust!(self.out, "}}"); rust!(self.out, ""); rust!( self.out, "fn expected_tokens(&self, state: {state_type}) -> Vec {{", state_type = state_type, ); rust!( self.out, "{p}expected_tokens(state as usize)", p = self.prefix ); rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "#[inline]"); rust!(self.out, "fn uses_error_recovery(&self) -> bool {{"); rust!(self.out, "{}", self.grammar.uses_error_recovery); rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "#[inline]"); rust!(self.out, "fn error_recovery_symbol("); rust!(self.out, "&self,"); rust!( self.out, "recovery: {p}state_machine::ErrorRecovery,", p = self.prefix ); rust!(self.out, ") -> Self::Symbol {{"); if self.grammar.uses_error_recovery { let error_variant = self.variant_name_for_symbol(&Symbol::Terminal(TerminalString::Error)); rust!( self.out, "{p}Symbol::{e}(recovery)", p = self.prefix, e = error_variant ); } else { rust!( self.out, "panic!(\"error recovery not enabled for this grammar\")" ) } rust!(self.out, "}}"); rust!(self.out, ""); rust!(self.out, "fn reduce("); rust!(self.out, "&mut self,"); rust!(self.out, "action: {state_type},", state_type = state_type); rust!(self.out, "start_location: Option<&Self::Location>,"); rust!( self.out, "states: &mut Vec<{state_type}>,", state_type = state_type ); rust!( self.out, "symbols: &mut Vec<{p}state_machine::SymbolTriple>,", p = self.prefix, ); rust!( self.out, ") -> Option<{p}state_machine::ParseResult> {{", p = self.prefix, ); rust!(self.out, "{p}reduce(", p = self.prefix); for Parameter { name, .. } in self.grammar.parameters.iter() { rust!(self.out, "self.{},", name); } rust!(self.out, "action,"); rust!(self.out, "start_location,"); rust!(self.out, "states,"); rust!(self.out, "symbols,"); rust!(self.out, "{},", phantom_data_expr); rust!(self.out, ")"); rust!(self.out, "}}"); rust!(self.out, ""); rust!( self.out, "fn simulate_reduce(&self, action: {state_type}) -> {p}state_machine::SimulatedReduce {{", p = self.prefix, state_type = state_type, ); rust!( self.out, "{p}simulate_reduce(action, {phantom})", p = self.prefix, phantom = phantom_data_expr, ); rust!(self.out, "}}"); rust!(self.out, "}}"); Ok(()) } fn write_value_type_defn(&mut self) -> io::Result<()> { // sometimes some of the variants are not used, particularly // if we are generating multiple parsers from the same file: rust!(self.out, "#[allow(dead_code)]"); rust!( self.out, "pub enum {}Symbol<{}>", self.prefix, Sep(", ", &self.custom.symbol_type_params), ); if !self.custom.symbol_where_clauses.is_empty() { rust!( self.out, " where {}", Sep(", ", &self.custom.symbol_where_clauses), ); } rust!(self.out, " {{"); // make one variant per terminal for term in &self.grammar.terminals.all { let ty = self.types.terminal_type(term).clone(); let len = self.custom.variants.len(); let name = match self.custom.variants.entry(ty.clone()) { Entry::Occupied(entry) => entry.into_mut(), Entry::Vacant(entry) => { let name = format!("Variant{}", len); rust!(self.out, "{}({}),", name, ty); entry.insert(name) } }; self.custom .variant_names .insert(Symbol::Terminal(term.clone()), name.clone()); } // make one variant per nonterminal for nt in self.grammar.nonterminals.keys() { let ty = self.types.nonterminal_type(nt).clone(); let len = self.custom.variants.len(); let name = match self.custom.variants.entry(ty.clone()) { Entry::Occupied(entry) => entry.into_mut(), Entry::Vacant(entry) => { let name = format!("Variant{}", len); rust!(self.out, "{}({}),", name, ty); entry.insert(name) } }; self.custom .variant_names .insert(Symbol::Nonterminal(nt.clone()), name.clone()); } rust!(self.out, "}}"); Ok(()) } fn write_parse_table(&mut self) -> io::Result<()> { // The table is a two-dimensional matrix indexed first by state // and then by the terminal index. The value is described above. rust!( self.out, "const {}ACTION: &'static [{}] = &[", self.prefix, self.custom.state_type ); for (index, state) in self.states.iter().enumerate() { rust!(self.out, "// State {}", index); if Tls::session().emit_comments { for item in state.items.vec.iter() { rust!(self.out, "// {:?}", item); } } // Write an action for each terminal (either shift, reduce, or error). let custom = &self.custom; let iterator = self.grammar.terminals.all.iter().map(|terminal| { if let Some(new_state) = state.shifts.get(&terminal) { ( new_state.0 as i32 + 1, Comment::Goto(Token::Terminal(terminal.clone()), new_state.0), ) } else { Self::write_reduction(custom, state, &Token::Terminal(terminal.clone())) } }); self.out.write_table_row(iterator)? } rust!(self.out, "];"); // Actions on EOF. Indexed just by state. rust!( self.out, "const {}EOF_ACTION: &'static [{}] = &[", self.prefix, self.custom.state_type ); for (index, state) in self.states.iter().enumerate() { rust!(self.out, "// State {}", index); let reduction = Self::write_reduction(&self.custom, state, &Token::EOF); self.out.write_table_row(Some(reduction))?; } rust!(self.out, "];"); // The goto table is indexed by state and *nonterminal*. rust!( self.out, "const {}GOTO: &'static [{}] = &[", self.prefix, self.custom.state_type ); for (index, state) in self.states.iter().enumerate() { rust!(self.out, "// State {}", index); let iterator = self.grammar.nonterminals.keys().map(|nonterminal| { if let Some(&new_state) = state.gotos.get(&nonterminal) { ( new_state.0 as i32 + 1, Comment::Goto(nonterminal, new_state.0), ) } else { (0, Comment::Error(nonterminal)) } }); self.out.write_table_row(iterator)?; } rust!(self.out, "];"); self.emit_expected_tokens_fn()?; Ok(()) } fn write_reduction<'s>( custom: &TableDriven<'grammar>, state: &'s LR1State, token: &Token, ) -> (i32, Comment<'s, Token>) { let reduction = state .reductions .iter() .filter(|&&(ref t, _)| t.contains(token)) .map(|&(_, p)| p) .next(); if let Some(production) = reduction { let action = custom.reduce_indices[production]; ( -(action as i32 + 1), Comment::Reduce(token.clone(), production), ) } else { // Otherwise, this is an error. Store 0. (0, Comment::Error(token.clone())) } } fn write_parser_fn(&mut self) -> io::Result<()> { let phantom_data_expr = self.phantom_data_expr(); self.start_parser_fn()?; self.define_tokens()?; rust!( self.out, "let {p}r = {p}state_machine::Parser::drive(", p = self.prefix, ); rust!(self.out, "{p}StateMachine {{", p = self.prefix); for Parameter { name, .. } in &self.grammar.parameters { rust!(self.out, "{},", name); } rust!( self.out, "{p}phantom: {phantom},", p = self.prefix, phantom = phantom_data_expr, ); rust!(self.out, "}},"); rust!(self.out, "{p}tokens,", p = self.prefix); rust!(self.out, ");"); rust!(self.out, "{p}r", p = self.prefix); self.end_parser_fn() } fn write_token_to_integer_fn(&mut self) -> io::Result<()> { let token_type = self.types.terminal_token_type(); let parameters = vec![ format!( "{p}token: &{token_type}", p = self.prefix, token_type = token_type, ), format!("_: {}", self.phantom_data_type()), ]; self.out .fn_header( &Visibility::Priv, format!("{p}token_to_integer", p = self.prefix), ) .with_type_parameters(&self.grammar.type_parameters) .with_where_clauses(&self.grammar.where_clauses) .with_parameters(parameters) .with_return_type("Option") .emit()?; rust!(self.out, "{{"); rust!(self.out, "match *{p}token {{", p = self.prefix); for (terminal, index) in self.grammar.terminals.all.iter().zip(0..) { if *terminal == TerminalString::Error { continue; } let pattern = self.grammar.pattern(terminal).map(&mut |_| "_"); rust!( self.out, "{pattern} if true => Some({index}),", pattern = pattern, index = index ); } rust!(self.out, "_ => None,"); rust!(self.out, "}}"); rust!(self.out, "}}"); Ok(()) } fn write_token_to_symbol_fn(&mut self) -> io::Result<()> { let symbol_type = self.symbol_type(); let token_type = self.types.terminal_token_type(); let parameters = vec![ format!("{p}token_index: usize", p = self.prefix,), format!( "{p}token: {token_type}", p = self.prefix, token_type = token_type, ), format!("_: {}", self.phantom_data_type()), ]; self.out .fn_header( &Visibility::Priv, format!("{p}token_to_symbol", p = self.prefix), ) .with_type_parameters(&self.grammar.type_parameters) .with_where_clauses(&self.grammar.where_clauses) .with_parameters(parameters) .with_return_type(symbol_type) .emit()?; rust!(self.out, "{{"); rust!(self.out, "match {p}token_index {{", p = self.prefix,); for (terminal, index) in self.grammar.terminals.all.iter().zip(0..) { if *terminal == TerminalString::Error { continue; } rust!(self.out, "{} => match {}token {{", index, self.prefix); let mut pattern_names = vec![]; let pattern = self.grammar.pattern(terminal).map(&mut |_| { let index = pattern_names.len(); pattern_names.push(format!("{}tok{}", self.prefix, index)); pattern_names.last().cloned().unwrap() }); let mut pattern = format!("{}", pattern); if pattern_names.is_empty() { pattern_names.push(format!("{}tok", self.prefix)); pattern = format!("{}tok @ {}", self.prefix, pattern); } let variant_name = self.variant_name_for_symbol(&Symbol::Terminal(terminal.clone())); rust!( self.out, "{pattern} => {p}Symbol::{variant_name}(({pattern_names})),", pattern = pattern, p = self.prefix, variant_name = variant_name, pattern_names = pattern_names.join(", "), ); rust!(self.out, "_ => unreachable!(),"); rust!(self.out, "}},"); } rust!(self.out, "_ => unreachable!(),"); rust!(self.out, "}}"); rust!(self.out, "}}"); Ok(()) } fn emit_reduce_actions(&mut self) -> io::Result<()> { let success_type = self.types.nonterminal_type(&self.start_symbol); let parse_error_type = self.types.parse_error_type(); let loc_type = self.types.terminal_loc_type(); let spanned_symbol_type = self.spanned_symbol_type(); let parameters = vec![ format!("{}action: {}", self.prefix, self.custom.state_type), format!("{}lookahead_start: Option<&{}>", self.prefix, loc_type), format!( "{}states: &mut ::std::vec::Vec<{}>", self.prefix, self.custom.state_type ), format!( "{}symbols: &mut ::std::vec::Vec<{}>", self.prefix, spanned_symbol_type ), format!("_: {}", self.phantom_data_type()), ]; self.out .fn_header( &Visibility::Pub(Some(Path::from_id(Atom::from("crate")))), format!("{}reduce", self.prefix), ) .with_grammar(self.grammar) .with_parameters(parameters) .with_return_type(format!( "Option>", success_type, parse_error_type )) .emit()?; rust!(self.out, "{{"); rust!( self.out, "let ({p}pop_states, {p}nonterminal) = match {}action {{", p = self.prefix ); for (production, index) in self .grammar .nonterminals .values() .flat_map(|nt| &nt.productions) .zip(0..) { rust!(self.out, "{} => {{", index); // In debug builds LLVM is not very good at reusing stack space which makes this // reduce function take up O(number of states) space. By wrapping each reduce action in // an immediately called function each reduction takes place in their own function // context which ends up reducing the stack space used. // Fallible actions and the start symbol may do early returns so we avoid wrapping // those let is_fallible = self.grammar.action_is_fallible(production.action); let reduce_stack_space = !is_fallible && production.nonterminal != self.start_symbol; if reduce_stack_space { self.custom.reduce_functions.insert(index); let phantom_data_expr = self.phantom_data_expr(); rust!( self.out, "{p}reduce{}({}{p}action, {p}lookahead_start, {p}states, {p}symbols, {})", index, self.grammar.user_parameter_refs(), phantom_data_expr, p = self.prefix ); } else { self.emit_reduce_action(production)?; } rust!(self.out, "}}"); } rust!( self.out, "_ => panic!(\"invalid action code {{}}\", {}action)", self.prefix ); rust!(self.out, "}};"); // pop the consumed states from the stack rust!( self.out, "let {p}states_len = {p}states.len();", p = self.prefix ); rust!( self.out, "{p}states.truncate({p}states_len - {p}pop_states);", p = self.prefix ); rust!( self.out, "let {}state = *{}states.last().unwrap() as usize;", self.prefix, self.prefix ); rust!( self.out, "let {}next_state = {}GOTO[{}state * {} + {}nonterminal] - 1;", self.prefix, self.prefix, self.prefix, self.grammar.nonterminals.len(), self.prefix ); if DEBUG_PRINT { rust!( self.out, "println!(\"goto state {{}} from {{}} due to nonterminal {{}}\", {}next_state, \ {}state, {}nonterminal);", self.prefix, self.prefix, self.prefix ); } rust!( self.out, "{}states.push({}next_state);", self.prefix, self.prefix ); rust!(self.out, "None"); rust!(self.out, "}}"); Ok(()) } fn emit_reduce_action_functions(&mut self) -> io::Result<()> { for (production, index) in self .grammar .nonterminals .values() .flat_map(|nt| &nt.productions) .zip(0..) { if self.custom.reduce_functions.contains(&index) { self.emit_reduce_alternative_fn_header(index)?; self.emit_reduce_action(production)?; rust!(self.out, "}}"); } } Ok(()) } fn emit_reduce_alternative_fn_header(&mut self, index: usize) -> io::Result<()> { let loc_type = self.types.terminal_loc_type(); let spanned_symbol_type = self.spanned_symbol_type(); let parameters = vec![ format!("{}action: {}", self.prefix, self.custom.state_type), format!("{}lookahead_start: Option<&{}>", self.prefix, loc_type), format!( "{}states: &mut ::std::vec::Vec<{}>", self.prefix, self.custom.state_type ), format!( "{}symbols: &mut ::std::vec::Vec<{}>", self.prefix, spanned_symbol_type ), format!("_: {}", self.phantom_data_type()), ]; self.out .fn_header( &Visibility::Pub(Some(Path::from_id(Atom::from("crate")))), format!("{}reduce{}", self.prefix, index), ) .with_grammar(self.grammar) .with_parameters(parameters) .with_return_type("(usize, usize)") .emit()?; rust!(self.out, "{{"); Ok(()) } fn emit_reduce_action(&mut self, production: &Production) -> io::Result<()> { rust!(self.out, "// {:?}", production); // Pop each of the symbols and their associated states. for (index, symbol) in production.symbols.iter().enumerate().rev() { let name = self.variant_name_for_symbol(symbol); rust!( self.out, "let {}sym{} = {}pop_{}({}symbols);", self.prefix, index, self.prefix, name, self.prefix ); } let transfer_syms: Vec<_> = (0..production.symbols.len()) .map(|i| format!("{}sym{}", self.prefix, i)) .collect(); // Execute the action fn // identify the "start" location for this production; this // is typically the start of the first symbol we are // reducing; but in the case of an empty production, it // will be the last symbol pushed, or at worst `default`. if let Some(first_sym) = transfer_syms.first() { rust!( self.out, "let {}start = {}.0.clone();", self.prefix, first_sym ); } else { // we pop no symbols, so grab from the top of the stack // (unless we are in the start state, in which case the // stack will be empty) rust!( self.out, "let {}start = {}symbols.last().map(|s| s.2.clone()).unwrap_or_default();", self.prefix, self.prefix ); } // identify the "end" location for this production; // this is typically the end of the last symbol we are reducing, // but in the case of an empty production it will come from the // lookahead if let Some(last_sym) = transfer_syms.last() { rust!(self.out, "let {}end = {}.2.clone();", self.prefix, last_sym); } else { rust!( self.out, "let {}end = {}lookahead_start.cloned().unwrap_or_else(|| \ {}start.clone());", self.prefix, self.prefix, self.prefix ); } let transfered_syms = transfer_syms.len(); let mut args = transfer_syms; if transfered_syms == 0 { args.push(format!("&{}start", self.prefix)); args.push(format!("&{}end", self.prefix)); } // invoke the action code let is_fallible = self.grammar.action_is_fallible(production.action); if is_fallible { rust!( self.out, "let {}nt = match {}::{}action{}::<{}>({}{}) {{", self.prefix, self.action_module, self.prefix, production.action.index(), Sep(", ", &self.grammar.non_lifetime_type_parameters()), self.grammar.user_parameter_refs(), Sep(", ", &args) ); rust!(self.out, "Ok(v) => v,"); rust!(self.out, "Err(e) => return Some(Err(e)),"); rust!(self.out, "}};"); } else { rust!( self.out, "let {}nt = {}::{}action{}::<{}>({}{});", self.prefix, self.action_module, self.prefix, production.action.index(), Sep(", ", &self.grammar.non_lifetime_type_parameters()), self.grammar.user_parameter_refs(), Sep(", ", &args) ); } // if this is the final state, return it if production.nonterminal == self.start_symbol { rust!(self.out, "return Some(Ok({}nt));", self.prefix); return Ok(()); } // push the produced value on the stack let name = self.variant_name_for_symbol(&Symbol::Nonterminal(production.nonterminal.clone())); rust!( self.out, "{}symbols.push(({}start, {}Symbol::{}({}nt), {}end));", self.prefix, self.prefix, self.prefix, name, self.prefix, self.prefix ); // produce the index that we will use to extract the next state // from GOTO array let index = self .custom .all_nonterminals .iter() .position(|x| *x == production.nonterminal) .unwrap(); rust!( self.out, "({len}, {index})", index = index, len = production.symbols.len() ); Ok(()) } fn variant_name_for_symbol(&self, s: &Symbol) -> String { self.custom.variant_names[s].clone() } fn emit_downcast_fns(&mut self) -> io::Result<()> { for (ty, name) in self.custom.variants.clone() { self.emit_downcast_fn(&name, ty)?; } Ok(()) } fn emit_downcast_fn(&mut self, variant_name: &str, variant_ty: TypeRepr) -> io::Result<()> { let spanned_symbol_type = self.spanned_symbol_type(); rust!(self.out, "fn {}pop_{}<", self.prefix, variant_name); for type_parameter in &self.custom.symbol_type_params { rust!(self.out, " {},", type_parameter); } rust!(self.out, ">("); rust!( self.out, "{}symbols: &mut ::std::vec::Vec<{}>", self.prefix, spanned_symbol_type ); rust!(self.out, ") -> {}", self.types.spanned_type(variant_ty)); if !self.custom.symbol_where_clauses.is_empty() { rust!( self.out, " where {}", Sep(", ", &self.custom.symbol_where_clauses) ); } rust!(self.out, " {{"); if DEBUG_PRINT { rust!(self.out, "println!(\"pop_{}\");", variant_name); } rust!(self.out, "match {}symbols.pop().unwrap() {{", self.prefix); rust!( self.out, "({}l, {}Symbol::{}({}v), {}r) => ({}l, {}v, {}r),", self.prefix, self.prefix, variant_name, self.prefix, self.prefix, self.prefix, self.prefix, self.prefix ); rust!(self.out, "_ => panic!(\"symbol type mismatch\")"); rust!(self.out, "}}"); rust!(self.out, "}}"); Ok(()) } fn write_simulate_reduce_fn(&mut self) -> io::Result<()> { let state_type = self.custom.state_type; let parameters = vec![ format!( "{p}reduce_index: {state_type}", p = self.prefix, state_type = state_type, ), format!("_: {}", self.phantom_data_type()), ]; self.out .fn_header( &Visibility::Priv, format!("{p}simulate_reduce", p = self.prefix), ) .with_type_parameters(&self.custom.machine.type_parameters) .with_where_clauses(&self.custom.machine.where_clauses) .with_parameters(parameters) .with_return_type(format!( "{p}state_machine::SimulatedReduce<{p}StateMachine<{mtp}>>", p = self.prefix, mtp = Sep(", ", &self.custom.machine.type_parameters), )) .emit()?; rust!(self.out, "{{"); rust!(self.out, "match {p}reduce_index {{", p = self.prefix,); for (production, index) in self .grammar .nonterminals .values() .flat_map(|nt| &nt.productions) .zip(0..) { if Tls::session().emit_comments { rust!(self.out, "// simulate {:?}", production); } // if we just reduced the start symbol, that is also an accept criteria if production.nonterminal == self.start_symbol { rust!( self.out, "{index} => {p}state_machine::SimulatedReduce::Accept,", index = index, p = self.prefix, ); } else { let num_symbols = production.symbols.len(); let nt = self .custom .all_nonterminals .iter() .position(|x| *x == production.nonterminal) .unwrap(); rust!(self.out, "{} => {{", index); if DEBUG_PRINT { rust!( self.out, "println!(r##\"accepts: simulating {:?}\"##);", production ); } rust!( self.out, "{p}state_machine::SimulatedReduce::Reduce {{", p = self.prefix, ); rust!( self.out, "states_to_pop: {num_symbols},", num_symbols = num_symbols, ); rust!(self.out, "nonterminal_produced: {nt},", nt = nt); rust!(self.out, "}}"); rust!(self.out, "}}"); } } rust!( self.out, "_ => panic!(\"invalid reduction index {{}}\", {}reduce_index)", self.prefix, ); rust!(self.out, "}}"); // end match rust!(self.out, "}}"); Ok(()) } /// The `accepts` function /// /// ```ignore /// fn __accepts() { /// error_state: i32, /// states: &Vec, /// opt_integer: Option, /// ) -> bool { /// ... /// } /// ``` /// /// has the job of figuring out whether the given error state would /// "accept" the given lookahead. We basically trace through the LR /// automaton looking for one of two outcomes: /// /// - the lookahead is eventually shifted /// - we reduce to the end state successfully (in the case of EOF). /// /// If we used the pure LR(1) algorithm, we wouldn't need this /// function, because we would be guaranteed to error immediately /// (and not after some number of reductions). But with an LALR /// (or Lane Table) generated automaton, it is possible to reduce /// some number of times before encountering an error. Failing to /// take this into account can lead error recovery into an /// infinite loop (see the `error_recovery_lalr_loop` test) or /// produce crappy results (see `error_recovery_lock_in`). fn write_accepts_fn(&mut self) -> io::Result<()> { if !self.grammar.uses_error_recovery { return Ok(()); } let phantom_data_expr = self.phantom_data_expr(); let actions_per_state = self.grammar.terminals.all.len(); let parameters = vec![ format!( "{p}error_state: {typ}", p = self.prefix, typ = self.custom.state_type ), format!( "{p}states: & [{typ}]", p = self.prefix, typ = self.custom.state_type ), format!("{p}opt_integer: Option", p = self.prefix), format!("_: {}", self.phantom_data_type()), ]; self.out .fn_header(&Visibility::Priv, format!("{}accepts", self.prefix)) .with_grammar(self.grammar) .with_parameters(parameters) .with_return_type("bool") .emit()?; rust!(self.out, "{{"); if DEBUG_PRINT { rust!( self.out, "println!(\"Testing whether state {{}} accepts token {{:?}}\", \ {p}error_state, {p}opt_integer);", p = self.prefix ); } // Create our own copy of the state stack to play with. rust!( self.out, "let mut {p}states = {p}states.to_vec();", p = self.prefix ); rust!(self.out, "{p}states.push({p}error_state);", p = self.prefix); rust!(self.out, "loop {{",); rust!( self.out, "let mut {}states_len = {}states.len();", self.prefix, self.prefix ); rust!( self.out, "let {p}top = {p}states[{p}states_len - 1] as usize;", p = self.prefix ); if DEBUG_PRINT { rust!( self.out, "println!(\"accepts: top-state={{}} num-states={{}}\", {p}top, {p}states_len);", p = self.prefix ); } rust!( self.out, "let {p}action = match {p}opt_integer {{", p = self.prefix ); rust!( self.out, "None => {p}EOF_ACTION[{p}top as usize],", p = self.prefix ); rust!( self.out, "Some({p}integer) => {p}ACTION[{p}top * {actions_per_state} + {p}integer],", p = self.prefix, actions_per_state = actions_per_state, ); rust!(self.out, "}};"); // end `match` // If we encounter an error action, we do **not** accept. rust!( self.out, "if {p}action == 0 {{ return false; }}", p = self.prefix ); // If we encounter a shift action, we DO accept. rust!( self.out, "if {p}action > 0 {{ return true; }}", p = self.prefix ); // If we encounter a reduce action, we need to simulate its // effect on the state stack. rust!( self.out, "let ({p}to_pop, {p}nt) = match {p}simulate_reduce(-({p}action + 1), {pde}) {{", p = self.prefix, pde = phantom_data_expr, ); rust!( self.out, "{p}state_machine::SimulatedReduce::Reduce {{", p = self.prefix, ); rust!(self.out, "states_to_pop, nonterminal_produced",); rust!(self.out, "}} => (states_to_pop, nonterminal_produced),",); rust!( self.out, "{p}state_machine::SimulatedReduce::Accept => return true,", p = self.prefix, ); rust!(self.out, "}};"); rust!(self.out, "{p}states_len -= {p}to_pop;", p = self.prefix); rust!( self.out, "{p}states.truncate({p}states_len);", p = self.prefix ); rust!( self.out, "let {p}top = {p}states[{p}states_len - 1] as usize;", p = self.prefix ); if DEBUG_PRINT { rust!( self.out, "println!(\"accepts: popped {{}} symbols, new top is {{}}, nt is {{}}\", \ {p}to_pop, \ {p}top, \ {p}nt, \ );", p = self.prefix ); } rust!( self.out, "let {p}next_state = {p}GOTO[{p}top * {num_non_terminals} + {p}nt] - 1;", p = self.prefix, num_non_terminals = self.grammar.nonterminals.len(), ); rust!(self.out, "{p}states.push({p}next_state);", p = self.prefix); rust!(self.out, "}}"); // end loop rust!(self.out, "}}"); // end fn Ok(()) } fn symbol_type(&self) -> String { format!( "{p}Symbol<{stp}>", p = self.prefix, stp = Sep(", ", &self.custom.symbol_type_params), ) } fn spanned_symbol_type(&self) -> String { let loc_type = self.types.terminal_loc_type(); format!("({},{},{})", loc_type, self.symbol_type(), loc_type) } fn emit_expected_tokens_fn(&mut self) -> io::Result<()> { rust!( self.out, "fn {}expected_tokens({}state: usize) -> Vec<::std::string::String> {{", self.prefix, self.prefix ); rust!( self.out, "const {}TERMINAL: &'static [&'static str] = &[", self.prefix ); let all_terminals = if self.grammar.uses_error_recovery { // Subtract one to exlude the error terminal &self.grammar.terminals.all[..self.grammar.terminals.all.len() - 1] } else { &self.grammar.terminals.all }; for terminal in all_terminals { // Three # should hopefully be enough to prevent any // reasonable terminal from escaping the literal rust!(self.out, "r###\"{}\"###,", terminal); } rust!(self.out, "];"); // Grab any terminals in the current state which would have resulted in a successful parse rust!( self.out, "{}ACTION[({}state * {})..].iter().zip({}TERMINAL).filter_map(|(&state, terminal)| {{", self.prefix, self.prefix, self.grammar.terminals.all.len(), self.prefix ); rust!(self.out, "if state == 0 {{"); rust!(self.out, "None"); rust!(self.out, "}} else {{"); rust!(self.out, "Some(terminal.to_string())"); rust!(self.out, "}}"); rust!(self.out, "}}).collect()"); rust!(self.out, "}}"); Ok(()) } } struct MachineParameters { type_parameters: Vec, fields: Vec, where_clauses: Vec, } impl MachineParameters { fn new(grammar: &Grammar) -> Self { let mut type_parameters = grammar.type_parameters.clone(); let mut where_clauses = grammar.where_clauses.clone(); let fields: Vec<_> = grammar .parameters .iter() .map(|Parameter { name, ty }| { let named_ty = ty.name_anonymous_lifetimes_and_compute_implied_outlives( &grammar.prefix, &mut type_parameters, &mut where_clauses, ); Parameter { name: name.clone(), ty: named_ty, } }) .collect(); // Put lifetimes first (this is stable, mind, so order remains // largely unperturbed): type_parameters.sort_by_key(|tp| match tp { TypeParameter::Lifetime(_) => 0, TypeParameter::Id(_) => 1, }); Self { type_parameters, fields, where_clauses, } } } lalrpop-0.17.2/src/lr1/codegen/test_all.rs000064400000000000000000000107031346406170700165170ustar0000000000000000//! A compiler from an LR(1) table to a [recursive ascent] parser. //! //! [recursive ascent]: https://en.wikipedia.org/wiki/Recursive_ascent_parser use grammar::repr::{Grammar, NonterminalString, TypeParameter}; use lr1::core::*; use rust::RustWrite; use std::io::{self, Write}; use util::Sep; use super::base::CodeGenerator; pub fn compile<'grammar, W: Write>( grammar: &'grammar Grammar, user_start_symbol: NonterminalString, start_symbol: NonterminalString, states: &[LR1State<'grammar>], out: &mut RustWrite, ) -> io::Result<()> { let mut ascent = CodeGenerator::new_test_all(grammar, user_start_symbol, start_symbol, states, out); ascent.write() } struct TestAll; impl<'ascent, 'grammar, W: Write> CodeGenerator<'ascent, 'grammar, W, TestAll> { fn new_test_all( grammar: &'grammar Grammar, user_start_symbol: NonterminalString, start_symbol: NonterminalString, states: &'ascent [LR1State<'grammar>], out: &'ascent mut RustWrite, ) -> Self { CodeGenerator::new( grammar, user_start_symbol, start_symbol, states, out, true, "super", TestAll, ) } fn write(&mut self) -> io::Result<()> { self.write_parse_mod(|this| { this.write_parser_fn()?; rust!(this.out, "#[cfg_attr(rustfmt, rustfmt_skip)]"); rust!(this.out, "mod {}ascent {{", this.prefix); super::ascent::compile( this.grammar, this.user_start_symbol.clone(), this.start_symbol.clone(), this.states, "super::super::super", this.out, )?; let pub_use = format!( "{}use self::{}parse{}::{}Parser;", this.grammar.nonterminals[&this.user_start_symbol].visibility, this.prefix, this.start_symbol, this.user_start_symbol ); rust!(this.out, "{}", pub_use); rust!(this.out, "}}"); rust!(this.out, "#[cfg_attr(rustfmt, rustfmt_skip)]"); rust!(this.out, "mod {}parse_table {{", this.prefix); super::parse_table::compile( this.grammar, this.user_start_symbol.clone(), this.start_symbol.clone(), this.states, "super::super::super", this.out, )?; rust!(this.out, "{}", pub_use); rust!(this.out, "}}"); Ok(()) }) } fn write_parser_fn(&mut self) -> io::Result<()> { self.start_parser_fn()?; if self.grammar.intern_token.is_some() { rust!(self.out, "let _ = self.builder;"); } // parse input using both methods: self.call_delegate("ascent")?; self.call_delegate("parse_table")?; // check that result is the same either way: rust!( self.out, "assert_eq!({}ascent, {}parse_table);", self.prefix, self.prefix ); rust!(self.out, "return {}ascent;", self.prefix); self.end_parser_fn()?; Ok(()) } fn call_delegate(&mut self, delegate: &str) -> io::Result<()> { let non_lifetimes: Vec<_> = self .grammar .type_parameters .iter() .filter(|&tp| match *tp { TypeParameter::Lifetime(_) => false, TypeParameter::Id(_) => true, }) .cloned() .collect(); let parameters = if non_lifetimes.is_empty() { String::new() } else { format!("::<{}>", Sep(", ", &non_lifetimes)) }; rust!( self.out, "let {}{} = {}{}::{}Parser::new().parse{}(", self.prefix, delegate, self.prefix, delegate, self.user_start_symbol, parameters ); for parameter in &self.grammar.parameters { rust!(self.out, "{},", parameter.name); } if self.grammar.intern_token.is_none() { rust!(self.out, "{}tokens0.clone(),", self.prefix); } rust!(self.out, ");"); Ok(()) } } lalrpop-0.17.2/src/lr1/core/mod.rs000064400000000000000000000233251346406170700150170ustar0000000000000000//! Core LR(1) types. use collections::Map; use grammar::repr::*; use itertools::Itertools; use std::fmt::{Debug, Display, Error, Formatter}; use std::rc::Rc; use util::Prefix; use super::lookahead::*; #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct Item<'grammar, L: Lookahead> { pub production: &'grammar Production, /// the dot comes before `index`, so `index` would be 1 for X = A (*) B C pub index: usize, pub lookahead: L, } pub type LR0Item<'grammar> = Item<'grammar, Nil>; pub type LR1Item<'grammar> = Item<'grammar, TokenSet>; impl<'grammar> Item<'grammar, Nil> { pub fn lr0(production: &'grammar Production, index: usize) -> Self { Item { production, index, lookahead: Nil, } } } impl<'grammar, L: Lookahead> Item<'grammar, L> { pub fn with_lookahead(&self, l: L1) -> Item<'grammar, L1> { Item { production: self.production, index: self.index, lookahead: l, } } pub fn prefix(&self) -> &'grammar [Symbol] { &self.production.symbols[..self.index] } pub fn symbol_sets(&self) -> SymbolSets<'grammar> { let symbols = &self.production.symbols; if self.can_shift() { SymbolSets { prefix: &symbols[..self.index], cursor: Some(&symbols[self.index]), suffix: &symbols[self.index + 1..], } } else { SymbolSets { prefix: &symbols[..self.index], cursor: None, suffix: &[], } } } pub fn to_lr0(&self) -> LR0Item<'grammar> { Item { production: self.production, index: self.index, lookahead: Nil, } } pub fn can_shift(&self) -> bool { self.index < self.production.symbols.len() } pub fn can_shift_nonterminal(&self, nt: &NonterminalString) -> bool { match self.shift_symbol() { Some((Symbol::Nonterminal(shifted), _)) => shifted == *nt, _ => false, } } pub fn can_shift_terminal(&self, term: &TerminalString) -> bool { match self.shift_symbol() { Some((Symbol::Terminal(shifted), _)) => shifted == *term, _ => false, } } pub fn can_reduce(&self) -> bool { self.index == self.production.symbols.len() } pub fn shifted_item(&self) -> Option<(Symbol, Item<'grammar, L>)> { if self.can_shift() { Some(( self.production.symbols[self.index].clone(), Item { production: self.production, index: self.index + 1, lookahead: self.lookahead.clone(), }, )) } else { None } } pub fn shift_symbol(&self) -> Option<(Symbol, &[Symbol])> { if self.can_shift() { Some(( self.production.symbols[self.index].clone(), &self.production.symbols[self.index + 1..], )) } else { None } } } #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct StateIndex(pub usize); #[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct Items<'grammar, L: Lookahead> { pub vec: Rc>>, } #[allow(dead_code)] pub type LR0Items<'grammar> = Items<'grammar, Nil>; #[allow(dead_code)] pub type LR1Items<'grammar> = Items<'grammar, TokenSet>; #[derive(Clone, Debug)] pub struct State<'grammar, L: Lookahead> { pub index: StateIndex, pub items: Items<'grammar, L>, pub shifts: Map, pub reductions: Vec<(L, &'grammar Production)>, pub gotos: Map, } pub type LR0State<'grammar> = State<'grammar, Nil>; pub type LR1State<'grammar> = State<'grammar, TokenSet>; #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum Action<'grammar> { Shift(TerminalString, StateIndex), Reduce(&'grammar Production), } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Conflict<'grammar, L> { // when in this state... pub state: StateIndex, // with the following lookahead... pub lookahead: L, // we can reduce... pub production: &'grammar Production, // but we can also... pub action: Action<'grammar>, } #[allow(dead_code)] pub type LR0Conflict<'grammar> = Conflict<'grammar, Nil>; pub type LR1Conflict<'grammar> = Conflict<'grammar, TokenSet>; #[derive(Debug)] pub struct TableConstructionError<'grammar, L: Lookahead> { // LR(1) state set, possibly incomplete if construction is // configured to terminate early. pub states: Vec>, // Conflicts (non-empty) found in those states. pub conflicts: Vec>, } pub type LR0TableConstructionError<'grammar> = TableConstructionError<'grammar, Nil>; pub type LR1TableConstructionError<'grammar> = TableConstructionError<'grammar, TokenSet>; pub type LRResult<'grammar, L> = Result>, TableConstructionError<'grammar, L>>; pub type LR1Result<'grammar> = LRResult<'grammar, TokenSet>; impl<'grammar, L: Lookahead> Debug for Item<'grammar, L> { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!( fmt, "{} ={} (*){}", self.production.nonterminal, Prefix(" ", &self.production.symbols[..self.index]), Prefix(" ", &self.production.symbols[self.index..]) )?; self.lookahead.fmt_as_item_suffix(fmt) } } impl Display for Token { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { Token::EOF => write!(fmt, "EOF"), Token::Error => write!(fmt, "Error"), Token::Terminal(ref s) => write!(fmt, "{}", s), } } } impl Debug for Token { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}", self) } } impl Debug for StateIndex { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "S{}", self.0) } } impl Display for StateIndex { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "{}", self.0) } } impl<'grammar, L: Lookahead> State<'grammar, L> { /// Returns the set of symbols which must appear on the stack to /// be in this state. This is the *maximum* prefix of any item, /// basically. pub fn max_prefix(&self) -> &'grammar [Symbol] { // Each state fn takes as argument the longest prefix of any // item. Note that all items must have compatible prefixes. let prefix = self .items .vec .iter() .map(Item::prefix) .max_by_key(|symbols| symbols.len()) .unwrap(); debug_assert!(self .items .vec .iter() .all(|item| prefix.ends_with(&item.production.symbols[..item.index]))); prefix } /// Returns the set of symbols from the stack that must be popped /// for this state to return. If we have a state like: /// /// ``` /// X = A B C (*) C /// Y = B C (*) C /// C = (*) ... /// ``` /// /// This would return `[B, C]`. For every state other than the /// start state, this will return a list of length at least 1. /// For the start state, returns `[]`. pub fn will_pop(&self) -> &'grammar [Symbol] { let prefix = self .items .vec .iter() .filter(|item| item.index > 0) .map(Item::prefix) .min_by_key(|symbols| symbols.len()) .unwrap_or(&[]); debug_assert!(self .items .vec .iter() .filter(|item| item.index > 0) .all(|item| item.prefix().ends_with(prefix))); prefix } pub fn will_push(&self) -> &[Symbol] { self.items .vec .iter() .filter(|item| item.index > 0) .map(|item| &item.production.symbols[item.index..]) .min_by_key(|symbols| symbols.len()) .unwrap_or(&[]) } /// Returns the type of nonterminal that this state will produce; /// if `None` is returned, then this state may produce more than /// one kind of nonterminal. /// /// FIXME -- currently, the start state returns `None` instead of /// the goal symbol. pub fn will_produce(&self) -> Option { let mut returnable_nonterminals: Vec<_> = self .items .vec .iter() .filter(|item| item.index > 0) .map(|item| item.production.nonterminal.clone()) .dedup() .collect(); if returnable_nonterminals.len() == 1 { returnable_nonterminals.pop() } else { None } } } /// `A = B C (*) D E F` or `A = B C (*)` #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub struct SymbolSets<'grammar> { pub prefix: &'grammar [Symbol], // both cases, [B, C] pub cursor: Option<&'grammar Symbol>, // first [D], second [] pub suffix: &'grammar [Symbol], // first [E, F], second [] } impl<'grammar> SymbolSets<'grammar> { pub fn new() -> Self { SymbolSets { prefix: &[], cursor: None, suffix: &[], } } } lalrpop-0.17.2/src/lr1/error/mod.rs000064400000000000000000000741531346406170700152250ustar0000000000000000//! Error reporting. For now very stupid and simplistic. use collections::{set, Set}; use grammar::repr::*; use itertools::Itertools; use lr1::core::*; use lr1::example::{Example, ExampleStyles, ExampleSymbol}; use lr1::first::FirstSets; use lr1::lookahead::{Token, TokenSet}; use lr1::trace::Tracer; use message::builder::{BodyCharacter, Builder, Character, MessageBuilder}; use message::Message; use tls::Tls; #[cfg(test)] mod test; pub fn report_error(grammar: &Grammar, error: &LR1TableConstructionError) -> Vec { let mut cx = ErrorReportingCx::new(grammar, &error.states, &error.conflicts); cx.report_errors() } struct ErrorReportingCx<'cx, 'grammar: 'cx> { grammar: &'grammar Grammar, first_sets: FirstSets, states: &'cx [LR1State<'grammar>], conflicts: &'cx [LR1Conflict<'grammar>], } #[derive(Debug)] enum ConflictClassification { /// The grammar is ambiguous. This means we have two examples of /// precisely the same set of symbols which can be reduced in two /// distinct ways. Ambiguity { action: Example, reduce: Example }, /// The grammar is ambiguous, and moreover it looks like a /// precedence error. This means that the reduction is to a /// nonterminal `T` and the shift is some symbol sandwiched /// between two instances of `T`. Precedence { shift: Example, reduce: Example, nonterminal: NonterminalString, }, /// Suggest inlining `nonterminal`. Makes sense if there are two /// levels in the reduction tree in both examples, and the suffix /// after the inner reduction is the same in all cases. SuggestInline { shift: Example, reduce: Example, nonterminal: NonterminalString, }, /// Like the previous, but suggest replacing `nonterminal` with /// `symbol?`. Makes sense if the thing to be inlined consists of /// two alternatives, `X = symbol | ()`. SuggestQuestion { shift: Example, reduce: Example, nonterminal: NonterminalString, symbol: Symbol, }, /// Can't say much beyond that a conflict occurred. InsufficientLookahead { action: Example, reduce: Example }, /// Really can't say *ANYTHING*. Naive, } type TokenConflict<'grammar> = Conflict<'grammar, Token>; impl<'cx, 'grammar> ErrorReportingCx<'cx, 'grammar> { fn new( grammar: &'grammar Grammar, states: &'cx [LR1State<'grammar>], conflicts: &'cx [LR1Conflict<'grammar>], ) -> Self { ErrorReportingCx { grammar, first_sets: FirstSets::new(grammar), states, conflicts, } } fn report_errors(&mut self) -> Vec { token_conflicts(self.conflicts) .iter() .map(|conflict| self.report_error(conflict)) .collect() } fn report_error(&mut self, conflict: &TokenConflict<'grammar>) -> Message { match self.classify(conflict) { ConflictClassification::Ambiguity { action, reduce } => { self.report_error_ambiguity(conflict, action, reduce) } ConflictClassification::Precedence { shift, reduce, nonterminal, } => self.report_error_precedence(conflict, shift, reduce, nonterminal), ConflictClassification::SuggestInline { shift, reduce, nonterminal, } => self.report_error_suggest_inline(conflict, shift, reduce, nonterminal), ConflictClassification::SuggestQuestion { shift, reduce, nonterminal, symbol, } => self.report_error_suggest_question(conflict, shift, reduce, nonterminal, symbol), ConflictClassification::InsufficientLookahead { action, reduce } => { self.report_error_insufficient_lookahead(conflict, action, reduce) } ConflictClassification::Naive => self.report_error_naive(conflict), } } fn report_error_ambiguity_core( &self, conflict: &TokenConflict<'grammar>, shift: Example, reduce: Example, ) -> Builder { let styles = ExampleStyles::ambig(); MessageBuilder::new(conflict.production.span) .heading() .text("Ambiguous grammar detected") .end() .body() .begin_lines() .wrap_text("The following symbols can be reduced in two ways:") .push(reduce.to_symbol_list(reduce.symbols.len(), styles)) .end() .begin_lines() .wrap_text("They could be reduced like so:") .push(reduce.into_picture(styles)) .end() .begin_lines() .wrap_text("Alternatively, they could be reduced like so:") .push(shift.into_picture(styles)) .end() } fn report_error_ambiguity( &self, conflict: &TokenConflict<'grammar>, shift: Example, reduce: Example, ) -> Message { self.report_error_ambiguity_core(conflict, shift, reduce) .wrap_text( "LALRPOP does not yet support ambiguous grammars. \ See the LALRPOP manual for advice on \ making your grammar unambiguous.", ) .end() .end() } fn report_error_precedence( &self, conflict: &TokenConflict<'grammar>, shift: Example, reduce: Example, nonterminal: NonterminalString, ) -> Message { self.report_error_ambiguity_core(conflict, shift, reduce) .begin_wrap() .text("Hint:") .styled(Tls::session().hint_text) .text("This looks like a precedence error related to") .push(nonterminal) .verbatimed() .punctuated(".") .text("See the LALRPOP manual for advice on encoding precedence.") .end() .end() .end() } fn report_error_not_lr1_core( &self, conflict: &TokenConflict<'grammar>, action: Example, reduce: Example, ) -> Builder { let styles = ExampleStyles::new(); let builder = MessageBuilder::new(conflict.production.span) .heading() .text("Local ambiguity detected") .end() .body(); let builder = builder .begin_lines() .begin_wrap() .text("The problem arises after having observed the following symbols") .text("in the input:") .end() .push(if action.cursor >= reduce.cursor { action.to_symbol_list(action.cursor, styles) } else { reduce.to_symbol_list(reduce.cursor, styles) }) .begin_wrap(); let builder = match conflict.lookahead { Token::Terminal(ref term) => builder .text("At that point, if the next token is a") .push(term.clone()) .verbatimed() .styled(Tls::session().cursor_symbol) .punctuated(","), Token::Error => builder.text("If an error has been found,"), Token::EOF => builder.text("If the end of the input is reached,"), }; let builder = builder .text("then the parser can proceed in two different ways.") .end() .end(); let builder = self.describe_reduce(builder, styles, conflict.production, reduce, "First"); match conflict.action { Action::Shift(ref lookahead, _) => { self.describe_shift(builder, styles, lookahead.clone(), action, "Alternatively") } Action::Reduce(production) => { self.describe_reduce(builder, styles, production, action, "Alternatively") } } } fn describe_shift( &self, builder: Builder, styles: ExampleStyles, lookahead: TerminalString, example: Example, intro_word: &str, ) -> Builder { // A shift example looks like: // // ...p1 ...p2 (*) L ...s2 ...s1 // | | | | // | +-NT1-----------+ | // | | // | ... | // | | // +-NT2-----------------------+ let nt1 = example.reductions[0].nonterminal.clone(); builder .begin_lines() .begin_wrap() .text(intro_word) .punctuated(",") .text("the parser could shift the") .push(lookahead) .verbatimed() .text("token and later use it to construct a") .push(nt1) .verbatimed() .punctuated(".") .text("This might then yield a parse tree like") .end() .push(example.into_picture(styles)) .end() } fn describe_reduce( &self, builder: Builder, styles: ExampleStyles, production: &Production, example: Example, intro_word: &str, ) -> Builder { builder .begin_lines() .begin_wrap() .text(intro_word) .punctuated(",") .text("the parser could execute the production at") .push(production.span) .punctuated(",") .text("which would consume the top") .text(production.symbols.len()) .text("token(s) from the stack") .text("and produce a") .push(production.nonterminal.clone()) .verbatimed() .punctuated(".") .text("This might then yield a parse tree like") .end() .push(example.into_picture(styles)) .end() } fn report_error_suggest_inline( &self, conflict: &TokenConflict<'grammar>, shift: Example, reduce: Example, nonterminal: NonterminalString, ) -> Message { let builder = self.report_error_not_lr1_core(conflict, shift, reduce); builder .begin_wrap() .text("Hint:") .styled(Tls::session().hint_text) .text("It appears you could resolve this problem by adding") .text("the annotation `#[inline]` to the definition of") .push(nonterminal) .verbatimed() .punctuated(".") .text("For more information, see the section on inlining") .text("in the LALRPOP manual.") .end() .end() .end() } fn report_error_suggest_question( &self, conflict: &TokenConflict<'grammar>, shift: Example, reduce: Example, nonterminal: NonterminalString, symbol: Symbol, ) -> Message { let builder = self.report_error_not_lr1_core(conflict, shift, reduce); builder .begin_wrap() .text("Hint:") .styled(Tls::session().hint_text) .text("It appears you could resolve this problem by replacing") .text("uses of") .push(nonterminal.clone()) .verbatimed() .text("with") .text(symbol) // intentionally disable coloring here, looks better .adjacent_text("`", "?`") .text( "(or, alternatively, by adding the annotation `#[inline]` \ to the definition of", ) .push(nonterminal) .punctuated(").") .text("For more information, see the section on inlining") .text("in the LALROP manual.") .end() .end() .end() } fn report_error_insufficient_lookahead( &self, conflict: &TokenConflict<'grammar>, action: Example, reduce: Example, ) -> Message { // The reduce example will look something like: // // // ...p1 ...p2 (*) L ...s2 ...s1 // | | | | // | +-NT1-----------+ | // | | | | // | +-...-----------+ | // | | | | // | +-NTn-----------+ | // | | // +-NTn+1---------------------+ // // To solve the conflict, essentially, the user needs to // modify the grammar so that `NTn` does not appear with `L` // in its follow-set. How to guide them in this? let builder = self.report_error_not_lr1_core(conflict, action, reduce); builder .wrap_text( "See the LALRPOP manual for advice on \ making your grammar LR(1).", ) .end() .end() } /// Naive error reporting. This is a fallback path which (I think) /// never actually executes. fn report_error_naive(&self, conflict: &TokenConflict<'grammar>) -> Message { let mut builder = MessageBuilder::new(conflict.production.span) .heading() .text("Conflict detected") .end() .body() .begin_lines() .wrap_text("when in this state:") .indented(); for item in self.states[conflict.state.0].items.vec.iter() { builder = builder.text(format!("{:?}", item)); } let mut builder = builder .end() .begin_wrap() .text(format!("and looking at a token `{:?}`", conflict.lookahead)) .text("we can reduce to a") .push(conflict.production.nonterminal.clone()) .verbatimed(); builder = match conflict.action { Action::Shift(..) => builder.text("but we can also shift"), Action::Reduce(prod) => builder .text("but we can also reduce to a") .text(prod.nonterminal.clone()) .verbatimed(), }; builder.end().end().end() } fn classify(&mut self, conflict: &TokenConflict<'grammar>) -> ConflictClassification { // Find examples from the conflicting action (either a shift // or a reduce). let mut action_examples = match conflict.action { Action::Shift(..) => self.shift_examples(conflict), Action::Reduce(production) => { self.reduce_examples(conflict.state, production, conflict.lookahead.clone()) } }; // Find examples from the conflicting reduce. let mut reduce_examples = self.reduce_examples( conflict.state, conflict.production, conflict.lookahead.clone(), ); // Prefer shorter examples to longer ones. action_examples.sort_by(|e, f| e.symbols.len().cmp(&f.symbols.len())); reduce_examples.sort_by(|e, f| e.symbols.len().cmp(&f.symbols.len())); // This really shouldn't happen, but if we've failed to come // up with examples, then report a "naive" error. if action_examples.is_empty() || reduce_examples.is_empty() { return ConflictClassification::Naive; } if let Some(classification) = self.try_classify_ambiguity(conflict, &action_examples, &reduce_examples) { return classification; } if let Some(classification) = self.try_classify_question(conflict, &action_examples, &reduce_examples) { return classification; } if let Some(classification) = self.try_classify_inline(conflict, &action_examples, &reduce_examples) { return classification; } // Give up. Just grab an example from each and pair them up. // If there aren't even two examples, something's pretty // bogus, but we'll just call it naive. action_examples .into_iter() .zip(reduce_examples) .next() .map( |(action, reduce)| ConflictClassification::InsufficientLookahead { action, reduce }, ) .unwrap_or(ConflictClassification::Naive) } fn try_classify_ambiguity( &self, conflict: &TokenConflict<'grammar>, action_examples: &[Example], reduce_examples: &[Example], ) -> Option { action_examples .iter() .cartesian_product(reduce_examples) .filter(|&(action, reduce)| action.symbols == reduce.symbols) .filter(|&(action, reduce)| action.cursor == reduce.cursor) .map(|(action, reduce)| { // Consider whether to call this a precedence // error. We do this if we are stuck between reducing // `T = T S T` and shifting `S`. if let Action::Shift(ref term, _) = conflict.action { let nt = &conflict.production.nonterminal; if conflict.production.symbols.len() == 3 && conflict.production.symbols[0] == Symbol::Nonterminal(nt.clone()) && conflict.production.symbols[1] == Symbol::Terminal(term.clone()) && conflict.production.symbols[2] == Symbol::Nonterminal(nt.clone()) { return ConflictClassification::Precedence { shift: action.clone(), reduce: reduce.clone(), nonterminal: nt.clone(), }; } } ConflictClassification::Ambiguity { action: action.clone(), reduce: reduce.clone(), } }) .next() } fn try_classify_question( &self, conflict: &TokenConflict<'grammar>, action_examples: &[Example], reduce_examples: &[Example], ) -> Option { // If we get a shift/reduce conflict and the reduce // is of a nonterminal like: // // T = { () | U } // // then suggest replacing T with U?. I'm being a bit lenient // here since I do not KNOW that it will help, but it often // does, and it's better style anyhow. if let Action::Reduce(_) = conflict.action { return None; } debug!( "try_classify_question: action_examples={:?}", action_examples ); debug!( "try_classify_question: reduce_examples={:?}", reduce_examples ); let nt = &conflict.production.nonterminal; let nt_productions = self.grammar.productions_for(nt); if nt_productions.len() == 2 { for &(i, j) in &[(0, 1), (1, 0)] { if nt_productions[i].symbols.is_empty() && nt_productions[j].symbols.len() == 1 { return Some(ConflictClassification::SuggestQuestion { shift: action_examples[0].clone(), reduce: reduce_examples[0].clone(), nonterminal: nt.clone(), symbol: nt_productions[j].symbols[0].clone(), }); } } } None } fn try_classify_inline( &self, conflict: &TokenConflict<'grammar>, action_examples: &[Example], reduce_examples: &[Example], ) -> Option { // Inlining can help resolve a shift/reduce conflict because // it defers the need to reduce. In particular, if we inlined // all the reductions up until the last one, then we would be // able to *shift* the lookahead instead of having to reduce. // This can be helpful if we can see that shifting would let // us delay reducing until the lookahead diverges. // Only applicable to shift/reduce: if let Action::Reduce(_) = conflict.action { return None; } // FIXME: The logic here finds the first example where inline // would help; but maybe we want to restrict it to cases // where inlining would help *all* the examples...? action_examples .iter() .cartesian_product(reduce_examples) .filter_map(|(shift, reduce)| { if self.try_classify_inline_example(shift, reduce) { let nt = &reduce.reductions[0].nonterminal; Some(ConflictClassification::SuggestInline { shift: shift.clone(), reduce: reduce.clone(), nonterminal: nt.clone(), }) } else { None } }) .next() } fn try_classify_inline_example(&self, shift: &Example, reduce: &Example) -> bool { debug!("try_classify_inline_example({:?}, {:?})", shift, reduce); // In the case of shift, the example will look like // // ``` // ... ... (*) L ...s1 ... // | | | | // | +-R0----------+ | // | ... | // +-Rn------------------+ // ``` // // We want to extract the symbols ...s1: these are the // things we are able to shift before being forced to // make our next hard decision (to reduce R0 or not). let shift_upcoming = &shift.symbols[shift.cursor + 1..shift.reductions[0].end]; debug!( "try_classify_inline_example: shift_upcoming={:?}", shift_upcoming ); // For the reduce, the example might look like // // ``` // ... ... (*) ...s ... // | | | | | // | | +-R0-+ | // | | ... | | // | +--Ri--+ | // | ... | // +-R(i+1)----------+ // ``` // // where Ri is the last reduction that requires // shifting no additional symbols. In this case, if we // inlined R0...Ri, then we know we can shift L. let r0_end = reduce.reductions[0].end; let i = reduce.reductions.iter().position(|r| r.end != r0_end); let i = match i { Some(v) => v, None => return false, }; let ri = &reduce.reductions[i]; let reduce_upcoming = &reduce.symbols[r0_end..ri.end]; debug!( "try_classify_inline_example: reduce_upcoming={:?} i={:?}", reduce_upcoming, i ); // For now, we only suggest inlining a single nonterminal, // mostly because I am too lazy to weak the suggestion struct // and error messages (but the rest of the code below doesn't // make this assumption for the most part). if i != 1 { return false; } // Make sure that all the things we are suggesting inlining // are distinct so that we are not introducing a cycle. let mut duplicates = set(); if reduce.reductions[0..=i] .iter() .any(|r| !duplicates.insert(r.nonterminal.clone())) { return false; } // Compare the two suffixes to see whether they // diverge at some point. shift_upcoming .iter() .zip(reduce_upcoming) .filter_map(|(shift_sym, reduce_sym)| match (shift_sym, reduce_sym) { (&ExampleSymbol::Symbol(ref shift_sym), &ExampleSymbol::Symbol(ref reduce_sym)) => { if shift_sym == reduce_sym { // same symbol on both; we'll be able to shift them None } else { // different symbols: for this to work, must // have disjoint first sets. Note that we // consider a suffix matching epsilon to be // potentially overlapping, though we could // supply the actual lookahead for more precision. let shift_first = self.first_sets.first0(&[shift_sym.clone()]); let reduce_first = self.first_sets.first0(&[reduce_sym.clone()]); if shift_first.is_disjoint(&reduce_first) { Some(true) } else { Some(false) } } } _ => { // we don't expect to encounter any // epsilons, I don't think, because those // only occur with an empty reduce at the // top level Some(false) } }) .next() .unwrap_or(false) } fn shift_examples(&self, conflict: &TokenConflict<'grammar>) -> Vec { log!(Tls::session(), Verbose, "Gathering shift examples"); let state = &self.states[conflict.state.0]; let conflicting_items = self.conflicting_shift_items(state, conflict); conflicting_items .into_iter() .flat_map(|item| { let tracer = Tracer::new(&self.first_sets, self.states); let shift_trace = tracer.backtrace_shift(conflict.state, item); let local_examples: Vec = shift_trace.lr0_examples(item).collect(); local_examples }) .collect() } fn reduce_examples( &self, state: StateIndex, production: &'grammar Production, lookahead: Token, ) -> Vec { log!(Tls::session(), Verbose, "Gathering reduce examples"); let item = Item { production, index: production.symbols.len(), lookahead: TokenSet::from(lookahead), }; let tracer = Tracer::new(&self.first_sets, self.states); let reduce_trace = tracer.backtrace_reduce(state, item.to_lr0()); reduce_trace.lr1_examples(&self.first_sets, &item).collect() } fn conflicting_shift_items( &self, state: &LR1State<'grammar>, conflict: &TokenConflict<'grammar>, ) -> Set> { // Lookahead must be a terminal, not EOF. // Find an item J like `Bar = ... (*) L ...`. let lookahead = Symbol::Terminal(conflict.lookahead.unwrap_terminal().clone()); state .items .vec .iter() .filter(|i| i.can_shift()) .filter(|i| i.production.symbols[i.index] == lookahead) .map(Item::to_lr0) .collect() } } fn token_conflicts<'grammar>( conflicts: &[Conflict<'grammar, TokenSet>], ) -> Vec> { conflicts .iter() .flat_map(|conflict| { conflict.lookahead.iter().map(move |token| Conflict { state: conflict.state, lookahead: token, production: conflict.production, action: conflict.action.clone(), }) }) .collect() } //fn choose_example<'grammar>(states: &[State<'grammar>], // lookahead: Token, // conflict: &TokenConflict<'grammar>) //{ // // Whenever we have a conflict in state S, there is always: // // - a given lookahead L that permits some reduction, due to // // an item I like `Foo = ... (*) [L]` // // - another action that conflicts with R1. // // // // The backtrace code can give context to this item `I`, but the // // problem is that it often results in many different contexts, // // and we need to try and narrow those down to the one that will // // help the user understand the problem. // // // // For that, we turn to the conflicting action, which can either be // // a shift or reduce. Let's consider those two cases. // // // // ### Shift // // // // If the conflicting action is a shift, then there is at least // // one item J in the state S like `Bar = ... (*) L ...`. We can // // produce a backtrace from J and enumerate examples. We want to // // find a pair of examples from I and J that share a common // // prefix. // // // // ### Reduce // // // // If the conflicting action is a reduce, then there is at least // // one item J in S like `Bar = ... (*) [L]`. We can produce a // // backtrace for J and then search for an example that shares a // // common prefix. // //} // //fn conflicting_item<'grammar>(state: &State<'grammar>, // lookahead: Token, // conflict: &TokenConflict<'grammar>) // -> Item<'grammar> //{ // match conflict.action { // Action::Shift(_) => { // } // Action::Reduce(production) => { // // Must be at least some other item J in S like `Bar = ... (*) [L]`. // state.items.vec.iter() // .filter(|i| i.can_reduce()) // .filter(|i| i.lookahead == lookahead) // .filter(|i| i.production == production) // .cloned() // .next() // .unwrap() // } // } //} lalrpop-0.17.2/src/lr1/error/test.rs000064400000000000000000000120711341573331700154130ustar0000000000000000use grammar::repr::*; use lr1::build_states; use lr1::tls::Lr1Tls; use string_cache::DefaultAtom as Atom; use test_util::normalized_grammar; use tls::Tls; use super::{ConflictClassification, ErrorReportingCx}; fn nt(t: &str) -> NonterminalString { NonterminalString(Atom::from(t)) } #[test] fn priority_conflict() { let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; pub Ty: () = { "int" => (), "bool" => (), "->" => (), }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let err = build_states(&grammar, nt("Ty")).unwrap_err(); let mut cx = ErrorReportingCx::new(&grammar, &err.states, &err.conflicts); let conflicts = super::token_conflicts(&err.conflicts); let conflict = &conflicts[0]; println!("conflict={:?}", conflict); match cx.classify(conflict) { ConflictClassification::Precedence { shift, reduce, nonterminal, } => { println!( "shift={:#?}, reduce={:#?}, nonterminal={:?}", shift, reduce, nonterminal ); assert_eq!(shift.symbols.len(), 5); // Ty -> Ty -> Ty assert_eq!(shift.cursor, 3); // Ty -> Ty -> Ty assert_eq!(shift.symbols, reduce.symbols); assert_eq!(shift.cursor, reduce.cursor); assert_eq!(nonterminal, nt("Ty")); } r => panic!("wrong classification {:#?}", r), } } #[test] fn expr_braced_conflict() { let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; pub Expr: () = { "Id" => (), "Id" "{" "}" => (), "Expr" "+" "Id" => (), "if" Expr "{" "}" => (), }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let err = build_states(&grammar, nt("Expr")).unwrap_err(); let mut cx = ErrorReportingCx::new(&grammar, &err.states, &err.conflicts); let conflicts = super::token_conflicts(&err.conflicts); let conflict = &conflicts[0]; println!("conflict={:?}", conflict); match cx.classify(conflict) { ConflictClassification::InsufficientLookahead { .. } => {} r => panic!("wrong classification {:#?}", r), } } #[test] fn suggest_question_conflict() { let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; pub E: () = { "L", "&" OPT_L E }; OPT_L: () = { (), "L" }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let err = build_states(&grammar, nt("E")).unwrap_err(); let mut cx = ErrorReportingCx::new(&grammar, &err.states, &err.conflicts); let conflicts = super::token_conflicts(&err.conflicts); let conflict = &conflicts[0]; println!("conflict={:?}", conflict); match cx.classify(conflict) { ConflictClassification::SuggestQuestion { shift: _, reduce: _, nonterminal, symbol, } => { assert_eq!(nonterminal, nt("OPT_L")); assert_eq!( symbol, Symbol::Terminal(TerminalString::quoted(Atom::from("L"))) ); } r => panic!("wrong classification {:#?}", r), } } #[test] fn suggest_inline_conflict() { let _tls = Tls::test(); let grammar = normalized_grammar( r##" grammar; pub ImportDecl: () = { "import" ";" => (), "import" "." "*" ";" => (), }; Path: () = { )*> => () }; Ident = r#"[a-zA-Z][a-zA-Z0-9]*"#; "##, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let err = build_states(&grammar, nt("ImportDecl")).unwrap_err(); let mut cx = ErrorReportingCx::new(&grammar, &err.states, &err.conflicts); let conflicts = super::token_conflicts(&err.conflicts); let conflict = &conflicts[0]; println!("conflict={:?}", conflict); match cx.classify(conflict) { ConflictClassification::SuggestInline { shift: _, reduce: _, nonterminal, } => { assert_eq!(nonterminal, nt("Path")); } r => panic!("wrong classification {:#?}", r), } } /// This example used to cause an out-of-bounds error. #[test] fn issue_249() { let _tls = Tls::test(); let grammar = normalized_grammar( r##" grammar; pub Func = StructDecl* VarDecl*; StructDecl = "<" StructParameter* ">"; StructParameter = "may_dangle"?; VarDecl = "let"; "##, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let err = build_states(&grammar, nt("Func")).unwrap_err(); let mut cx = ErrorReportingCx::new(&grammar, &err.states, &err.conflicts); let conflicts = super::token_conflicts(&err.conflicts); for conflict in &conflicts { println!("conflict={:?}", conflict); cx.classify(conflict); } } lalrpop-0.17.2/src/lr1/example/mod.rs000064400000000000000000000334441350346013400155140ustar0000000000000000//! Code to compute example inputs given a backtrace. use ascii_canvas::AsciiView; use grammar::repr::*; use message::builder::InlineBuilder; use message::Content; use std::fmt::{Debug, Error, Formatter}; use style::Style; use tls::Tls; #[cfg(test)] mod test; /// An "example" input and the way it was derived. This can be /// serialized into useful text. For example, it might represent /// something like this: /// /// ``` /// Looking at /// | /// v /// Ty "->" Ty "->" Ty /// | | | /// +-Ty-----+ | /// | | /// +-Ty-------------+ /// ``` /// /// The top-line is the `symbols` vector. The groupings below are /// stored in the `reductions` vector, in order from smallest to /// largest (they are always properly nested). The `cursor` field /// indicates the current lookahead token. /// /// The `symbols` vector is actually `Option` to account /// for empty reductions: /// /// ``` /// A B /// | | | | /// | +-Y-+ | /// +-Z-----+ /// ``` /// /// The "empty space" between A and B would be represented as `None`. #[derive(Clone, Debug)] pub struct Example { pub symbols: Vec, pub cursor: usize, pub reductions: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum ExampleSymbol { Symbol(Symbol), Epsilon, } #[derive(Copy, Clone, Default)] pub struct ExampleStyles { pub before_cursor: Style, pub on_cursor: Style, pub after_cursor: Style, } #[derive(Clone, Debug)] pub struct Reduction { pub start: usize, pub end: usize, pub nonterminal: NonterminalString, } impl Example { /// Length of each symbol. Each will need *at least* that amount /// of space. :) Measure in characters, under the assumption of a /// mono-spaced font. Also add a final `0` marker which will serve /// as the end position. fn lengths(&self) -> Vec { self.symbols .iter() .map(|s| match *s { ExampleSymbol::Symbol(ref s) => format!("{}", s).chars().count(), ExampleSymbol::Epsilon => 1, // display as " " }) .chain(Some(0)) .collect() } /// Extract a prefix of the list of symbols from this `Example` /// and make a styled list of them, like: /// /// Ty "->" Ty -> "Ty" pub fn to_symbol_list(&self, length: usize, styles: ExampleStyles) -> Box { let mut builder = InlineBuilder::new().begin_spaced(); for (index, symbol) in self.symbols[..length].iter().enumerate() { let style = if index < self.cursor { styles.before_cursor } else if index > self.cursor { styles.after_cursor } else { match *symbol { ExampleSymbol::Symbol(Symbol::Terminal(_)) => styles.on_cursor, ExampleSymbol::Symbol(Symbol::Nonterminal(_)) => styles.after_cursor, ExampleSymbol::Epsilon => styles.after_cursor, } }; if let ExampleSymbol::Symbol(ref s) = symbol { builder = builder.push(s.clone()).styled(style); } } builder.end().indented().end() } /// Render the example into a styled diagram suitable for /// embedding in an error message. pub fn into_picture(self, styles: ExampleStyles) -> Box { let lengths = self.lengths(); let positions = self.positions(&lengths); InlineBuilder::new() .push(Box::new(ExamplePicture { example: self, positions, styles, })) .indented() .end() } fn starting_positions(&self, lengths: &[usize]) -> Vec { lengths .iter() .scan(0, |counter, &len| { let start = *counter; // Leave space for "NT " (if "NT" is the name // of the nonterminal). *counter = start + len + 1; Some(start) }) .collect() } /// Start index where each symbol in the example should appear, /// measured in characters. These are spaced to leave enough room /// for the reductions below. fn positions(&self, lengths: &[usize]) -> Vec { // Initially, position each symbol with one space in between, // like: // // X Y Z let mut positions = self.starting_positions(lengths); // Adjust spacing to account for the nonterminal labels // we will have to add. It will display // like this: // // A1 B2 C3 D4 E5 F6 // | | // +-Label---+ // // But if the label is long we may have to adjust the spacing // of the covered items (here, we changed them to two spaces, // except the first gap, which got 3 spaces): // // A1 B2 C3 D4 E5 F6 // | | // +-LongLabel22-+ for &Reduction { start, end, ref nonterminal, } in &self.reductions { let nt_len = format!("{}", nonterminal).chars().count(); // Number of symbols we are reducing. This should always // be non-zero because even in the case of a \epsilon // rule, we ought to be have a `None` entry in the symbol array. let num_syms = end - start; assert!(num_syms > 0); // Let's use the expansion from above as our running example. // We start out with positions like this: // // A1 B2 C3 D4 E5 F6 // | | // +-LongLabel22-+ // // But we want LongLabel to end at D4. No good. // Start of first symbol to be reduced. Here, 0. // // A1 B2 C3 D4 // ^ here let start_position = positions[start]; // End of last symbol to be reduced. Here, 11. // // A1 B2 C3 D4 E5 // ^ positions[end] // ^ here -- positions[end] - 1 let end_position = positions[end] - 1; // We need space to draw `+-Label-+` between // start_position and end_position. let required_len = nt_len + 4; // here, 15 let actual_len = end_position - start_position; // here, 10 if required_len < actual_len { continue; // Got enough space, all set. } // Have to add `difference` characters altogether. let difference = required_len - actual_len; // here, 4 // Increment over everything that is not part of this nonterminal. // In the example above, that is E5 and F6. shift(&mut positions[end..], difference); if num_syms > 1 { // If there is just one symbol being reduced here, // then we have shifted over the things that follow // it, and we are done. This would be a case like: // // X Y Z // | | // +-Label-+ // // (which maybe ought to be rendered slightly // differently). // // But if there are multiple symbols, we're not quite // done, because there would be an unsightly gap: // // (gaps) // | | | // v v v // A1 B2 C3 D4 E5 F6 // | | // +-LongLabel22-+ // // we'd like to make things line up, so we have to // distribute that extra space internally by // increasing the "gaps" (marked above) as evenly as // possible (basically, full justification). // // We do this by dividing up the spaces evenly and // then taking the remainder `N` and distributing 1 // extra to the first N. let num_gaps = num_syms - 1; // number of gaps we can adjust. Here, 3. let amount = difference / num_gaps; // what to add to each gap. Here, 1. let extra = difference % num_gaps; // the remainder. Here, 1. // For the first `extra` symbols, give them amount + 1 // extra space. After that, just amount. (O(n^2). Sue me.) for i in 0..extra { shift(&mut positions[start + 1 + i..end], amount + 1); } for i in extra..num_gaps { shift(&mut positions[start + 1 + i..end], amount); } } } positions } #[cfg(test)] pub fn paint_unstyled(&self) -> Vec<::ascii_canvas::Row> { let this = self.clone(); let content = this.into_picture(ExampleStyles::default()); let min_width = content.min_width(); let canvas = content.emit_to_canvas(min_width); canvas.to_strings() } fn paint_on(&self, styles: &ExampleStyles, positions: &[usize], view: &mut dyn AsciiView) { // Draw the brackets for each reduction: for (index, reduction) in self.reductions.iter().enumerate() { let start_column = positions[reduction.start]; let end_column = positions[reduction.end] - 1; let row = 1 + index; view.draw_vertical_line(0..row + 1, start_column); view.draw_vertical_line(0..row + 1, end_column - 1); view.draw_horizontal_line(row, start_column..end_column); } // Write the labels for each reduction. Do this after the // brackets so that ascii canvas can convert `|` to `+` // without interfering with the text (in case of weird overlap). let session = Tls::session(); for (index, reduction) in self.reductions.iter().enumerate() { let column = positions[reduction.start] + 2; let row = 1 + index; view.write_chars( row, column, reduction.nonterminal.to_string().chars(), session.nonterminal_symbol, ); } // Write the labels on top: // A1 B2 C3 D4 E5 F6 self.paint_symbols_on(&self.symbols, &positions, styles, view); } fn paint_symbols_on( &self, symbols: &[ExampleSymbol], positions: &[usize], styles: &ExampleStyles, view: &mut dyn AsciiView, ) { let session = Tls::session(); for (index, ex_symbol) in symbols.iter().enumerate() { let style = if index < self.cursor { styles.before_cursor } else if index == self.cursor { // Only display actual terminals in the "on-cursor" // font, because it might be misleading to show a // nonterminal that way. Really it'd be nice to expand // so that the cursor is always a terminal. match *ex_symbol { ExampleSymbol::Symbol(Symbol::Terminal(_)) => styles.on_cursor, _ => styles.after_cursor, } } else { styles.after_cursor }; let column = positions[index]; match *ex_symbol { ExampleSymbol::Symbol(Symbol::Terminal(ref term)) => { view.write_chars( 0, column, term.to_string().chars(), style.with(session.terminal_symbol), ); } ExampleSymbol::Symbol(Symbol::Nonterminal(ref nt)) => { view.write_chars( 0, column, nt.to_string().chars(), style.with(session.nonterminal_symbol), ); } ExampleSymbol::Epsilon => {} } } } } struct ExamplePicture { example: Example, positions: Vec, styles: ExampleStyles, } impl Content for ExamplePicture { fn min_width(&self) -> usize { *self.positions.last().unwrap() } fn emit(&self, view: &mut dyn AsciiView) { self.example.paint_on(&self.styles, &self.positions, view); } fn into_wrap_items(self: Box, wrap_items: &mut Vec>) { wrap_items.push(self); } } impl Debug for ExamplePicture { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Debug::fmt(&self.example, fmt) } } fn shift(positions: &mut [usize], amount: usize) { for position in positions { *position += amount; } } impl ExampleStyles { pub fn ambig() -> Self { let session = Tls::session(); ExampleStyles { before_cursor: session.ambig_symbols, on_cursor: session.ambig_symbols, after_cursor: session.ambig_symbols, } } pub fn new() -> Self { let session = Tls::session(); ExampleStyles { before_cursor: session.observed_symbols, on_cursor: session.cursor_symbol, after_cursor: session.unobserved_symbols, } } } lalrpop-0.17.2/src/lr1/example/test.rs000064400000000000000000000122631341573331700157200ustar0000000000000000use grammar::repr::*; use string_cache::DefaultAtom as Atom; use test_util::expect_debug; use tls::Tls; use super::{Example, ExampleSymbol, Reduction}; fn nt(t: &str) -> NonterminalString { NonterminalString(Atom::from(t)) } fn term(t: &str) -> TerminalString { TerminalString::quoted(Atom::from(t)) } macro_rules! sym { (ε) => { ExampleSymbol::Epsilon }; ($t:ident) => { ExampleSymbol::Symbol(Symbol::Nonterminal(nt(stringify!($t)))) }; } macro_rules! syms { ($($t:tt),*) => { vec![$(sym!($t)),*] } } // 01234567890123456789012 // A1 B2 C3 D4 E5 F6 // | | | // +-LongLabel22-+ | // | | // +-Label-------------+ fn long_label_1_example() -> Example { Example { symbols: syms!(A1, B2, C3, D4, E5, F6), cursor: 5, reductions: vec![ Reduction { start: 0, end: 4, nonterminal: nt("LongLabel22"), }, Reduction { start: 0, end: 6, nonterminal: nt("Label"), }, ], } } #[test] fn long_label_1_positions() { let _tls = Tls::test(); let example = long_label_1_example(); let lengths = example.lengths(); let positions = example.positions(&lengths); assert_eq!(positions, vec![0, 5, 9, 13, 16, 19, 22]); } #[test] fn long_label_1_strings() { let _tls = Tls::test(); let strings = long_label_1_example().paint_unstyled(); expect_debug( strings, r#" [ " A1 B2 C3 D4 E5 F6", " ├─LongLabel22─┘ │", " └─Label─────────────┘" ] "# .trim(), ); } // Example with some empty sequences and // other edge cases. // // 012345678901234567890123456789012345 // A1 B2 C3 D4 E5 F6 // | | | | | | | // +-X-+ | | | | | // | | | | | | // +-MegaLongLabel-+ | | | | // | | | | // +-Y-+ | | // | | // +-Z-+ fn empty_labels_example() -> Example { Example { // 0 1 2 3 4 5 6 7 symbols: syms!(ε, A1, B2, C3, D4, E5, ε, F6), cursor: 5, reductions: vec![ Reduction { start: 0, end: 1, nonterminal: nt("X"), }, Reduction { start: 0, end: 4, nonterminal: nt("MegaLongLabel"), }, Reduction { start: 6, end: 7, nonterminal: nt("Y"), }, Reduction { start: 7, end: 8, nonterminal: nt("Z"), }, ], } } #[test] fn empty_labels_positions() { let _tls = Tls::test(); let example = empty_labels_example(); let lengths = example.lengths(); let positions = example.positions(&lengths); // A1 B2 C3 D4 E5 F6 assert_eq!(positions, vec![0, 7, 11, 15, 18, 21, 24, 30, 36]); } #[test] fn empty_labels_strings() { let _tls = Tls::test(); let strings = empty_labels_example().paint_unstyled(); expect_debug( strings, r#" [ " ╷ ╷ A1 B2 C3 D4 E5 ╷ ╷ F6 ╷", " ├─X──┘ │ │ │ │ │", " └─MegaLongLabel─┘ │ │ │ │", " └─Y─┘ │ │", " └─Z─┘" ] "# .trim(), ); } // _return_ _A_ Expression _B_ // | | | // +-ExprAtom---+ | // | | | // +-ExprSuffix-+ | // | | // +-ExprSuffix--------------------+ fn single_token_example() -> Example { Example { // 0 1 2 3 4 5 6 7 symbols: syms!(_return_, _A_, Expression, _B_), cursor: 5, reductions: vec![ Reduction { start: 0, end: 1, nonterminal: nt("ExprAtom"), }, Reduction { start: 0, end: 1, nonterminal: nt("ExprSuffix"), }, Reduction { start: 0, end: 4, nonterminal: nt("ExprSuffix"), }, ], } } #[test] fn single_token_strings() { let _tls = Tls::test(); let strings = single_token_example().paint_unstyled(); expect_debug( strings, r#" [ " _return_ ╷ _A_ Expression _B_", " ├─ExprAtom───┤ │", " ├─ExprSuffix─┘ │", " └─ExprSuffix────────────────────┘" ] "# .trim(), ); } lalrpop-0.17.2/src/lr1/first/mod.rs000064400000000000000000000065211346406170700152150ustar0000000000000000//! First set construction and computation. use collections::{map, Map}; use grammar::repr::*; use lr1::lookahead::{Token, TokenSet}; #[cfg(test)] mod test; #[derive(Clone)] pub struct FirstSets { map: Map, } impl FirstSets { pub fn new(grammar: &Grammar) -> FirstSets { let mut this = FirstSets { map: map() }; let mut changed = true; while changed { changed = false; for production in grammar.nonterminals.values().flat_map(|p| &p.productions) { let nt = &production.nonterminal; let lookahead = this.first0(&production.symbols); let first_set = this.map.entry(nt.clone()).or_insert_with(TokenSet::new); changed |= first_set.union_with(&lookahead); } } this } /// Returns `FIRST(...symbols)`. If `...symbols` may derive /// epsilon, then this returned set will include EOF. (This is /// kind of repurposing EOF to serve as a binary flag of sorts.) pub fn first0<'s, I>(&self, symbols: I) -> TokenSet where I: IntoIterator, { let mut result = TokenSet::new(); for symbol in symbols { match *symbol { Symbol::Terminal(ref t) => { result.insert(Token::Terminal(t.clone())); return result; } Symbol::Nonterminal(ref nt) => { let mut empty_prod = false; match self.map.get(nt) { None => { // This should only happen during set // construction; it corresponds to an // entry that has not yet been // built. Otherwise, it would mean a // terminal with no productions. Either // way, the resulting first set should be // empty. } Some(set) => { for lookahead in set.iter() { match lookahead { Token::EOF => { empty_prod = true; } Token::Error | Token::Terminal(_) => { result.insert(lookahead); } } } } } if !empty_prod { return result; } } } } // control only reaches here if either symbols is empty, or it // consists of nonterminals all of which may derive epsilon result.insert(Token::EOF); result } pub fn first1(&self, symbols: &[Symbol], lookahead: &TokenSet) -> TokenSet { let mut set = self.first0(symbols); // we use EOF as the signal that `symbols` derives epsilon: let epsilon = set.take_eof(); if epsilon { set.union_with(&lookahead); } set } } lalrpop-0.17.2/src/lr1/first/test.rs000064400000000000000000000044671341573331700154230ustar0000000000000000use super::FirstSets; use grammar::repr::*; use lr1::lookahead::Token::EOF; use lr1::lookahead::{Token, TokenSet}; use lr1::tls::Lr1Tls; use string_cache::DefaultAtom as Atom; use test_util::normalized_grammar; pub fn nt(t: &str) -> Symbol { Symbol::Nonterminal(NonterminalString(Atom::from(t))) } pub fn term(t: &str) -> Symbol { Symbol::Terminal(TerminalString::quoted(Atom::from(t))) } fn la(t: &str) -> Token { Token::Terminal(TerminalString::quoted(Atom::from(t))) } fn first0(first: &FirstSets, symbols: &[Symbol]) -> Vec { let v = first.first0(symbols); v.iter().collect() } fn first1(first: &FirstSets, symbols: &[Symbol], lookahead: Token) -> Vec { let v = first.first1(symbols, &TokenSet::from(lookahead)); v.iter().collect() } #[test] fn basic_first1() { let grammar = normalized_grammar( r#" grammar; A = B "C"; B: Option = { "D" => Some(1), => None }; X = "E"; // intentionally unreachable "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let first_sets = FirstSets::new(&grammar); assert_eq!(first1(&first_sets, &[nt("A")], EOF), vec![la("C"), la("D")]); assert_eq!(first1(&first_sets, &[nt("B")], EOF), vec![la("D"), EOF]); assert_eq!( first1(&first_sets, &[nt("B"), term("E")], EOF), vec![la("D"), la("E")] ); assert_eq!( first1(&first_sets, &[nt("B"), nt("X")], EOF), vec![la("D"), la("E")] ); } #[test] fn basic_first0() { let grammar = normalized_grammar( r#" grammar; A = B "C"; B: Option = { "D" => Some(1), => None }; X = "E"; // intentionally unreachable "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let first_sets = FirstSets::new(&grammar); assert_eq!(first0(&first_sets, &[nt("A")]), vec![la("C"), la("D")]); assert_eq!(first0(&first_sets, &[nt("B")]), vec![la("D"), EOF]); assert_eq!( first0(&first_sets, &[nt("B"), term("E")]), vec![la("D"), la("E")] ); assert_eq!( first0(&first_sets, &[nt("B"), nt("X")]), vec![la("D"), la("E")] ); assert_eq!(first0(&first_sets, &[nt("X")]), vec![la("E")]); } lalrpop-0.17.2/src/lr1/interpret.rs000064400000000000000000000141541346406170700153240ustar0000000000000000//! LR(1) interpeter. Just builds up parse trees. Intended for testing. use generate::ParseTree; use grammar::repr::*; use lr1::core::*; use lr1::lookahead::*; use std::fmt::{Debug, Display, Error, Formatter}; use std::iter::IntoIterator; use util::Sep; pub type InterpretError<'grammar, L> = (&'grammar State<'grammar, L>, Token); /// Feed in the given tokens and then EOF, returning the final parse tree that is reduced. pub fn interpret<'grammar, L>( states: &'grammar [State<'grammar, L>], tokens: Vec, ) -> Result> where L: LookaheadInterpret, { println!("interpret(tokens={:?})", tokens); let mut m = Machine::new(states); m.execute(tokens.into_iter()) } /// Feed in the given tokens and returns the states on the stack. pub fn interpret_partial<'grammar, TOKENS, L>( states: &'grammar [State<'grammar, L>], tokens: TOKENS, ) -> Result, InterpretError<'grammar, L>> where TOKENS: IntoIterator, L: LookaheadInterpret, { let mut m = Machine::new(states); m.execute_partial(tokens.into_iter())?; Ok(m.state_stack) } struct Machine<'grammar, L: LookaheadInterpret + 'grammar> { states: &'grammar [State<'grammar, L>], state_stack: Vec, data_stack: Vec, } impl<'grammar, L> Machine<'grammar, L> where L: LookaheadInterpret, { fn new(states: &'grammar [State<'grammar, L>]) -> Machine<'grammar, L> { Machine { states, state_stack: vec![], data_stack: vec![], } } fn top_state(&self) -> &'grammar State<'grammar, L> { let index = self.state_stack.last().unwrap(); &self.states[index.0] } fn execute_partial( &mut self, mut tokens: TOKENS, ) -> Result<(), InterpretError<'grammar, L>> where TOKENS: Iterator, { assert!(self.state_stack.is_empty()); assert!(self.data_stack.is_empty()); self.state_stack.push(StateIndex(0)); let mut token = tokens.next(); while let Some(terminal) = token.clone() { let state = self.top_state(); println!("state={:?}", state); println!("terminal={:?}", terminal); // check whether we can shift this token if let Some(&next_index) = state.shifts.get(&terminal) { self.data_stack.push(ParseTree::Terminal(terminal.clone())); self.state_stack.push(next_index); token = tokens.next(); } else if let Some(production) = L::reduction(state, &Token::Terminal(terminal.clone())) { let more = self.reduce(production); assert!(more); } else { return Err((state, Token::Terminal(terminal.clone()))); } } Ok(()) } fn execute(&mut self, tokens: TOKENS) -> Result> where TOKENS: Iterator, { self.execute_partial(tokens)?; // drain now for EOF loop { let state = self.top_state(); match L::reduction(state, &Token::EOF) { None => { return Err((state, Token::EOF)); } Some(production) => { if !self.reduce(production) { assert_eq!(self.data_stack.len(), 1); return Ok(self.data_stack.pop().unwrap()); } } } } } fn reduce(&mut self, production: &Production) -> bool { println!("reduce={:?}", production); let args = production.symbols.len(); // remove the top N items from the data stack let mut popped = vec![]; for _ in 0..args { popped.push(self.data_stack.pop().unwrap()); } popped.reverse(); // remove the top N states for _ in 0..args { self.state_stack.pop().unwrap(); } // construct the new, reduced tree and push it on the stack let tree = ParseTree::Nonterminal(production.nonterminal.clone(), popped); self.data_stack.push(tree); // recover the state and extract the "Goto" action let receiving_state = self.top_state(); match receiving_state.gotos.get(&production.nonterminal) { Some(&goto_state) => { self.state_stack.push(goto_state); true // keep going } None => { false // all done } } } } impl Debug for ParseTree { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { Display::fmt(self, fmt) } } impl Display for ParseTree { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { match *self { ParseTree::Nonterminal(ref id, ref trees) => { write!(fmt, "[{}: {}]", id, Sep(", ", trees)) } ParseTree::Terminal(ref id) => write!(fmt, "{}", id), } } } pub trait LookaheadInterpret: Lookahead { fn reduction<'grammar>( state: &State<'grammar, Self>, token: &Token, ) -> Option<&'grammar Production>; } impl LookaheadInterpret for Nil { fn reduction<'grammar>( state: &State<'grammar, Self>, _token: &Token, ) -> Option<&'grammar Production> { state .reductions .iter() .map(|&(_, production)| production) .next() } } impl LookaheadInterpret for TokenSet { fn reduction<'grammar>( state: &State<'grammar, Self>, token: &Token, ) -> Option<&'grammar Production> { state .reductions .iter() .filter(|&&(ref tokens, _)| tokens.contains(token)) .map(|&(_, production)| production) .next() } } lalrpop-0.17.2/src/lr1/item.rs000064400000000000000000000000021341573331700142300ustar0000000000000000 lalrpop-0.17.2/src/lr1/lane_table/README.md000064400000000000000000000345451341573331700163140ustar0000000000000000This module contains code for LR(1) construction based on a paper by Pager and Chen, "The Lane Table Method Of Constructing LR(1) Parsers", published in APPLC '12. Unfortunately, that paper is quite compact -- only 8 pages! -- which doesn't leave much room for examples and explanation. This README is my attempt to explain the idea, or at least how I chose to implement it in LALRPOP, which may or may not be faithful to the original algorithm. Naturally it also serves as a guide to the code. ### First example grammar: G0 We will be working through two example grammars. The first I call G0 -- it is a reduced version of what the paper calls G1. It is interesting because it does not require splitting any states, and so we wind up with the same number of states as in LR0. Put another way, it is an LALR(1) grammar. #### Grammar G0 ``` G0 = X "c" | Y "d" X = "e" X | "e" Y = "e" Y | "e" ``` #### Step 1: Construct an LR(0) state machine We begin by constructing an LR(0) state machine. The LR(0) states for G0 are as follows: ``` S0 = G0 = (*) X "c" | G0 = (*) Y "d" | X = (*) "e" X | X = (*) "e" | Y = (*) "e" Y | Y = (*) "e" S1 = X = "e" (*) X | X = "e" (*) | X = (*) "e" | X = (*) "e" "X" | Y = "e" (*) Y | Y = "e" (*) | Y = (*) "e" | Y = (*) "e" Y S2 = X = "e" X (*) S3 = G0 = X (*) "c" S4 = Y = "e" Y (*) S5 = G0 = Y (*) "d" S6 = G0 = X "c" (*) S7 = G0 = Y "d" (*) ``` We can also consider *edges* between the states as follows, with the label being the symbol that is pushed onto the stack: ``` S0 -"e"-> S1 S1 -"e"-> S1 S1 --X--> S2 S0 --X--> S3 S1 --Y--> S4 S0 --Y--> S5 S3 -"c"-> S6 S5 -"d"-> S7 ``` Note that state S1 is "inconsistent", in that it has conflicting actions. #### Step 2: Convert LR(0) states into LR(0-1) states. The term LR(0-1), but basically the idea is that the lookahead in a LR(0-1) state can be either a set of terminals (as in LR(1)) or *none* (as in LR(0)). You can also think of it alternatively as adding a special "wildcard" symbol `_` to the grammar; in our actual code, we represent this with `TokenSet::all()`. We will thus denote the inconsistent state after transformation as follows, where each line has the "wildcard" lookahead: ``` S1 = X = "e" (*) X [_] | X = "e" (*) [_] | X = (*) "e" [_] | X = (*) "e" "X" [_] | Y = "e" (*) Y [_] | Y = "e" (*) [_] | Y = (*) "e" [_] | Y = (*) "e" Y [_] ``` Naturally, the state is still inconsistent. #### Step 3: Resolve inconsistencies. In the next step, we iterate over all of our LR(0-1) states. In this example, we will not need to create new states, but in future examples we will. The iteration thus consists of a queue and some code like this: ```rust let mut queue = Queue::new(); queue.extend(/* all states */); while let Some(s) = queue.pop_front() { if /* s is an inconsistent state */ { resolve_inconsistencies(s, &mut queue); } } ``` ##### Step 3a: Build the lane table. To resolve an inconsistent state, we first construct a **lane table**. This is done by the code in the `lane` module (the `table` module maintains the data structure). It works by structing at each conflict and tracing **backwards**. Let's start with the final table we will get for the state S1 and then we will work our way back to how it is constructed. First, let's identify the conflicting actions from S1 and give them indices: ``` S1 = X = (*) "e" [_] // C0 -- shift "e" | X = "e" (*) [_] // C1 -- reduce `X = "e" (*)` | X = (*) "e" "X" [_] // C0 -- shift "e" | X = "e" (*) X [_] | Y = (*) "e" [_] // C0 -- shift "e" | Y = "e" (*) [_] // C2 -- reduce `Y = "e" (*)` | Y = (*) "e" Y [_] // C0 -- shift "e" | Y = "e" (*) Y [_] ``` Several of the items can cause "Confliction Action 0" (C0), which is to shift an `"e"`. These are all mutually compatible. However, there are also two incompatible actions: C1 and C2, both reductions. In fact, we'll find that we look back at state S0, these 'conflicting' actions all occur with distinct lookahead. The purpose of the lane table is to summarize that information. The lane table we will up constructing for these conflicting actions is as follows: ``` | State | C0 | C1 | C2 | Successors | | S0 | | ["c"] | ["d"] | {S1} | | S1 | ["e"] | [] | [] | {S1} | ``` Here the idea is that the lane table summarizes the lookahead information contributed by each state. Note that for the *shift* the state S1 already has enough lookahead information: we only shift when we see the terminal we need next ("e"). But state C1 and C2, the lookahead actually came from S0, which is a predecessor state. As I said earlier, the algorithm for constructing the table works by looking at the conflicting item and walking backwards. So let's illustrate with conflict C1. We have the conflicting item `X = "e" (*)`, and we are basically looking to find its lookahead. We know that somewhere in the distant past of our state machine there must be an item like Foo = ...a (*) X ...b that led us here. We want to find that item, so we can derive the lookahead from `...b` (whatever symbols come after `X`). To do this, we will walk the graph. Our state at any point in time will be the pair of a state and an item in that state. To start out, then, we have `(S1, X = "e" (*))`, which is the conflict C1. Because the `(*)` is not at the "front" of this item, we have to figure out where this `"e"` came from on our stack, so we look for predecessors of the state S1 which have an item like `X = (*) e`. This leads us to S0 and also S1. So we can push two states in our search: `(S0, X = (*) "e")` and `(S1, X = (*) "e")`. Let's consider each in turn. The next state is then `(S0, X = (*) "e")`. Here the `(*)` lies at the front of the item, so we search **the same state** S0 for items that would have led to this state via an *epsilon move*. This basically means an item like `Foo = ... (*) X ...` -- i.e., where the `(*)` appears directly before the nonterminal `X`. In our case, we will find `G0 = (*) X "c"`. This is great, because it tells us some lookahead ("c", in particular), and hence we can stop our search. We add to the table the entry that the state S0 contributes lookahead "c" to the conflict C1. In some cases, we might find something like `Foo = ... (*) X` instead, where the `X` we are looking for appears at the end. In that case, we have to restart our search, but looking for the lookahead for `Foo`. The next state in our case is `(S1, X = (*) e)`. Again the `(*)` lies at the beginning and hence we search for things in the state S1 where `X` is the next symbol. We find `X = "e" (*) X`. This is not as good as last time, because there are no symbols appearing after X in this item, so it does not contribute any lookahead. We therefore can't stop our search yet, but we push the state `(S1, X = "e" (*) X)` -- this corresponds to the `Foo` state I mentioned at the end of the last paragraph, except that in this case `Foo` is the same nonterminal `X` we started with. Looking at `(S1, X = "e" (*) X)`, we again have the `(*)` in the middle of the item, so we move it left, searching for predecessors with the item `X = (*) e X`. We will (again) find S0 and S1 have such items. In the case of S0, we will (again) find the context "c", which we dutifully add to the table (this has no effect, since it is already present). In the case of S1, we will (again) wind up at the state `(S1, X = "e" (*) X)`. Since we've already visited this state, we stop our search, it will not lead to new context. At this point, our table column for C1 is complete. We can repeat the process for C2, which plays out in an analogous way. ##### Step 3b: Update the lookahead Looking at the lane table we built, we can union the context sets in any particular column. We see that the context sets for each conflicting action are pairwise disjoint. Therefore, we can simply update each reduce action in our state with those lookaheads in mind, and hence render it consistent: ``` S1 = X = (*) "e" [_] | X = "e" (*) ["c"] // lookahead from C1 | X = (*) "e" "X" [_] | X = "e" (*) X [_] | Y = (*) "e" [_] | Y = "e" (*) ["d"] // lookahead from C2 | Y = (*) "e" Y [_] | Y = "e" (*) Y [_] ``` This is of course also what the LALR(1) state would look like (though it would include context for the other items, though that doesn't play into the final machine execution). At this point we've covered enough to handle the grammar G0. Let's turn to a more complex grammar, grammar G1, and then we'll come back to cover the remaining steps. ### Second example: the grammar G1 G1 is a (typo corrected) version of the grammar from the paper. This grammar is not LALR(1) and hence it is more interesting, because it requires splitting states. #### Grammar G1 ``` G1 = "a" X "d" | "a" Y "c" | "b" X "c" | "b" Y "d" X = "e" X | "e" Y = "e" Y | "e" ``` The key point of this grammar is that when we see `... "e" "c"` and we wish to know whether to reduce to `X` or `Y`, we don't have enough information. We need to know what is in the `...`, because `"a" "e" "c"` means we reduce `"e"` to `Y` and `"b" "e" "c"` means we reduce to `X`. In terms of our *state machine*, this corresponds to *splitting* the states responsible for X and Y based on earlier context. Let's look at a subset of the LR(0) states for G1: ``` S0 = G0 = (*) "a" X "d" | G0 = (*) "a" Y "c" | G0 = (*) "b" X "c" | G0 = (*) "b" X "d" S1 = G0 = "a" (*) X "d" | G0 = "a" (*) Y "c" | X = (*) "e" X | X = (*) "e" | Y = (*) "e" Y | Y = (*) "e" S2 = G0 = "b" (*) X "c" | G0 = "b" (*) Y "d" | X = (*) "e" X | X = (*) "e" | Y = (*) "e" Y | Y = (*) "e" S3 = X = "e" (*) X | X = "e" (*) // C1 -- can reduce | X = (*) "e" // C0 -- can shift "e" | X = (*) "e" "X" // C0 -- can shift "e" | Y = "e" (*) Y | Y = "e" (*) // C2 -- can reduce | Y = (*) "e" // C0 -- can shift "e" | Y = (*) "e" Y // C0 -- can shift "e" ``` Here we can see the problem. The state S3 is inconsistent. But it is reachable from both S1 and S2. If we come from S1, then we can have (e.g.) `X "d"`, but if we come from S2, we expect `X "c"`. Let's walk through our algorithm again. I'll start with step 3a. ### Step 3a: Build the lane table. The lane table for state S3 will look like this: ``` | State | C0 | C1 | C2 | Successors | | S1 | | ["d"] | ["c"] | {S3} | | S2 | | ["c"] | ["d"] | {S3} | | S3 | ["e"] | [] | [] | {S3} | ``` Now if we union each column, we see that both C1 and C2 wind up with lookahead `{"c", "d"}`. This is our problem. We have to isolate things better. Therefore, step 3b ("update lookahead") does not apply. Instead we attempt step 3c. ### Step 3c: Isolate lanes This part of the algorithm is only loosely described in the paper, but I think it works as follows. We will employ a union-find data structure. With each set, we will record a "context set", which records for each conflict the set of lookahead tokens (e.g., `{C1:{"d"}}`). A context set tells us how to map the lookahead to an action; therefire, to be self-consistent, the lookaheads for each conflict must be mutually disjoint. In other words, `{C1:{"d"}, C2:{"c"}}` is valid, and says to do C1 if we see a "d" and C2 if we see a "c". But `{C1:{"d"}, C2:{"d"}}` is not, because there are two actions. Initially, each state in the lane table is mapped to itself, and the conflict set is derived from its column in the lane table: ``` S1 = {C1:d, C2:c} S2 = {C1:c, C2:d} S3 = {C0:e} ``` We designate "beachhead" states as those states in the table that are not reachable from another state in the table (i.e., using the successors). In this case, those are the states S1 and S2. We will be doing a DFS through the table and we want to use those as the starting points. (Question: is there always at least one beachhead state? Seems like there must be.) So we begin by iterating over the beachhead states. ```rust for beachhead in beachheads { ... } ``` When we visit a state X, we will examine each of its successors Y. We consider whether the context set for Y can be merged with the context set for X. So, in our case, X will be S1 to start and Y will be S3. In this case, the context set can be merged, and hence we union S1, S3 and wind up with the following union-find state: ``` S1,S3 = {C0:e, C1:d, C2:c} S2 = {C1:c, C2:d} ``` (Note that this union is just for the purpose of tracking context; it doesn't imply that S1 and S3 are the 'same states' or anything like that.) Next we examine the edge S3 -> S3. Here the contexts are already merged and everything is happy, so we stop. (We already visited S3, after all.) This finishes our first beachhead, so we proceed to the next edge, S2 -> S3. Here we find that we **cannot** union the context: it would produce an inconsistent state. So what we do is we **clone** S3 to make a new state, S3', with the initial setup corresponding to the row for S3 from the lane table: ``` S1,S3 = {C0:e, C1:d, C2:c} S2 = {C1:c, C2:d} S3' = {C0:e} ``` This also involves updating our LR(0-1) state set to have a new state S3'. All edges from S2 that led to S3 now lead to S3'; the outgoing edges from S3' remain unchanged. (At least to start.) Therefore, the edge `S2 -> S3` is now `S2 -> S3'`. We can now merge the conflicts: ``` S1,S3 = {C0:e, C1:d, C2:c} S2,S3' = {C0:e, C1:c, C2:d} ``` Now we examine the outgoing edge S3' -> S3. We cannot merge these conflicts, so we search (greedily, I guess) for a clone of S3 where we can merge the conflicts. We find one in S3', and hence we redirect the S3 edge to S3' and we are done. (I think the actual search we want is to make first look for a clone of S3 that is using literally the same context as us (i.e., same root node), as in this case. If that is not found, *then* we search for one with a mergable context. If *that* fails, then we clone a new state.) The final state thus has two copies of S3, one for the path from S1, and one for the path from S2, which gives us enough context to proceed. lalrpop-0.17.2/src/lr1/lane_table/construct/merge.rs000064400000000000000000000205141346406170700205160ustar0000000000000000use collections::{Map, Multimap, Set}; use ena::unify::InPlaceUnificationTable; use lr1::core::{Action, LR1State, StateIndex}; use lr1::lane_table::construct::state_set::StateSet; use lr1::lane_table::table::context_set::ContextSet; use lr1::lane_table::table::LaneTable; /// The "merge" phase of the algorithm is described in "Step 3c" of /// [the README][r]. It consists of walking through the various /// states in the lane table and merging them into sets of states that /// have compatible context sets; if we encounter a state S that has a /// successor T but where the context set of S is not compatible with /// T, then we will clone T into a new T2 (and hopefully the context /// set of S will be compatible with the reduced context of T2). /// /// [r]: ../README.md pub struct Merge<'m, 'grammar: 'm> { table: &'m LaneTable<'grammar>, states: &'m mut Vec>, visited: Set, original_indices: Map, clones: Multimap>, target_states: Vec, context_sets: ContextSets<'m>, } impl<'m, 'grammar> Merge<'m, 'grammar> { pub fn new( table: &'m LaneTable<'grammar>, unify: &'m mut InPlaceUnificationTable, states: &'m mut Vec>, state_sets: &'m mut Map, inconsistent_state: StateIndex, ) -> Self { Merge { table, states, visited: Set::new(), original_indices: Map::new(), clones: Multimap::new(), target_states: vec![inconsistent_state], context_sets: ContextSets { unify, state_sets }, } } pub fn start(&mut self, beachhead_state: StateIndex) -> Result<(), (StateIndex, StateIndex)> { debug!("Merge::start(beachhead_state={:?})", beachhead_state); // Since we always start walks from beachhead states, and they // are not reachable from anyone else, this state should not // have been unioned with anything else yet. self.walk(beachhead_state) } pub fn patch_target_starts(mut self, actions: &Set>) { debug!("Merge::patch_target_starts(actions={:?})", actions); for &target_state in &self.target_states { debug!( "Merge::patch_target_starts: target_state={:?}", target_state ); let context_set = self.context_sets.context_set(target_state); debug!("Merge::patch_target_starts: context_set={:?}", context_set); context_set.apply(&mut self.states[target_state.0], actions); } } /// If `state` is a cloned state, find its original index. Useful /// for indexing into the lane table and so forth. fn original_index(&self, state: StateIndex) -> StateIndex { *self.original_indices.get(&state).unwrap_or(&state) } fn successors(&self, state: StateIndex) -> Option<&'m Set> { self.table.successors(self.original_index(state)) } fn walk(&mut self, state: StateIndex) -> Result<(), (StateIndex, StateIndex)> { debug!("Merge::walk(state={:?})", state); if !self.visited.insert(state) { debug!("Merge::walk: visited already"); return Ok(()); } for &successor in self.successors(state).iter().flat_map(|&s| s) { debug!("Merge::walk: state={:?} successor={:?}", state, successor); if self.context_sets.union(state, successor) { debug!( "Merge::walk: successful union, context-set = {:?}", self.context_sets.context_set(state) ); self.walk(successor)?; } else { // search for an existing clone with which we can merge debug!("Merge::walk: union failed, seek existing clone"); let existing_clone = { let context_sets = &mut self.context_sets; self.clones .get(&successor) .into_iter() .flat_map(|clones| clones) // get() returns an Option .cloned() .find(|&successor1| context_sets.union(state, successor1)) }; if let Some(successor1) = existing_clone { debug!("Merge::walk: found existing clone {:?}", successor1); self.patch_links(state, successor, successor1); self.walk(successor1)?; } else { // if we don't find one, we have to make a new clone debug!("Merge::walk: creating new clone of {:?}", successor); let successor1 = self.clone(successor); if self.context_sets.union(state, successor1) { self.patch_links(state, successor, successor1); self.walk(successor1)?; } else { debug!( "Merge::walk: failed to union {:?} with {:?}", state, successor1 ); debug!( "Merge::walk: state context = {:?}", self.context_sets.context_set(state) ); debug!( "Merge::walk: successor context = {:?}", self.context_sets.context_set(successor1) ); return Err((self.original_index(state), self.original_index(successor1))); } } } } Ok(()) } fn clone(&mut self, state: StateIndex) -> StateIndex { // create a new state with same contents as the old one let new_index = StateIndex(self.states.len()); let new_state = self.states[state.0].clone(); self.states.push(new_state); // track the original index and clones let original_index = self.original_index(state); self.original_indices.insert(new_index, original_index); self.clones.push(original_index, new_index); // create a new unify key for this new state let context_set = self.table.context_set(original_index).unwrap(); self.context_sets.new_state(new_index, context_set); // keep track of the clones of the target state if original_index == self.target_states[0] { self.target_states.push(new_index); } debug!("Merge::clone: cloned {:?} to {:?}", state, new_index); new_index } fn patch_links( &mut self, predecessor: StateIndex, original_successor: StateIndex, cloned_successor: StateIndex, ) { let replace = |target_state: &mut StateIndex| { if *target_state == original_successor { *target_state = cloned_successor; } }; let state = &mut self.states[predecessor.0]; for target_state in state.shifts.values_mut() { replace(target_state); } for target_state in state.gotos.values_mut() { replace(target_state); } } } struct ContextSets<'m> { state_sets: &'m mut Map, unify: &'m mut InPlaceUnificationTable, } impl<'m> ContextSets<'m> { fn context_set(&mut self, state: StateIndex) -> ContextSet { let state_set = self.state_sets[&state]; self.unify.probe_value(state_set) } fn union(&mut self, source: StateIndex, target: StateIndex) -> bool { let set1 = self.state_sets[&source]; let set2 = self.state_sets[&target]; let result = self.unify.unify_var_var(set1, set2).is_ok(); debug!( "ContextSets::union: source={:?} target={:?} result={:?}", source, target, result ); result } fn new_state(&mut self, new_index: StateIndex, context_set: ContextSet) { let state_set = self.unify.new_key(context_set); self.state_sets.insert(new_index, state_set); } } lalrpop-0.17.2/src/lr1/lane_table/construct/mod.rs000064400000000000000000000225351346406170700202030ustar0000000000000000//! use collections::{Map, Set}; use ena::unify::InPlaceUnificationTable; use grammar::repr::*; use lr1::build; use lr1::core::*; use lr1::first::FirstSets; use lr1::lane_table::lane::LaneTracer; use lr1::lane_table::table::context_set::OverlappingLookahead; use lr1::lane_table::table::{ConflictIndex, LaneTable}; use lr1::lookahead::{Lookahead, TokenSet}; use lr1::state_graph::StateGraph; use std::rc::Rc; mod merge; use self::merge::Merge; mod state_set; use self::state_set::StateSet; pub struct LaneTableConstruct<'grammar> { grammar: &'grammar Grammar, first_sets: FirstSets, start_nt: NonterminalString, } impl<'grammar> LaneTableConstruct<'grammar> { pub fn new(grammar: &'grammar Grammar, start_nt: NonterminalString) -> Self { let first_sets = FirstSets::new(grammar); LaneTableConstruct { grammar, start_nt, first_sets, } } pub fn construct(self) -> Result>, LR1TableConstructionError<'grammar>> { let states = { match build::build_lr0_states(self.grammar, self.start_nt.clone()) { Ok(states) => { // In this case, the grammar is actually // LR(0). This is very rare -- it means that the // grammar does not need lookahead to execute. In // principle, we could stop here, except that if // we do so, then the lookahead values that we get // are very broad. // // Broad lookahead values will cause "eager" // reduce at runtime -- i.e., if there is some // scenario where the lookahead tells you we are // in error, but we would have to reduce a few // states before we see it. This, in turn, can // cause infinite loops around error recovery // (#240). // // Since we want to behave as a LR(1) parser // would, we'll just go ahead and run the // algorithm. states } Err(TableConstructionError { states, .. }) => states, } }; // Convert the LR(0) states into LR(0-1) states. let mut states = self.promote_lr0_states(states); // For each inconsistent state, apply the lane-table algorithm to // resolve it. for i in 0.. { if i >= states.len() { break; } match self.resolve_inconsistencies(&mut states, StateIndex(i)) { Ok(()) => {} Err(_) => { // We failed because of irreconcilable conflicts // somewhere. Just compute the conflicts from the final set of // states. debug!( "construct: failed to resolve inconsistencies in state {:#?}", states[i] ); let conflicts: Vec> = states .iter() .flat_map(|s| Lookahead::conflicts(&s)) .collect(); return Err(TableConstructionError { states, conflicts }); } } } Ok(states) } /// Given a set of LR0 states, returns LR1 states where the lookahead /// is always `TokenSet::all()`. We refer to these states as LR(0-1) /// states in the README. fn promote_lr0_states(&self, lr0: Vec>) -> Vec> { let all = TokenSet::all(); debug!("promote_lr0_states: all={:?}", all); lr0.into_iter() .map(|s| { let items = s .items .vec .iter() .map(|item| Item { production: item.production, index: item.index, lookahead: all.clone(), }) .collect(); let reductions = s .reductions .into_iter() .map(|(_, p)| (all.clone(), p)) .collect(); State { index: s.index, items: Items { vec: Rc::new(items), }, shifts: s.shifts, reductions, gotos: s.gotos, } }) .collect() } fn resolve_inconsistencies( &self, states: &mut Vec>, inconsistent_state: StateIndex, ) -> Result<(), StateIndex> { debug!( "resolve_inconsistencies(inconsistent_state={:?}/{:#?}", inconsistent_state, states[inconsistent_state.0] ); let mut actions = super::conflicting_actions(&states[inconsistent_state.0]); if actions.is_empty() { // This can mean one of two things: only shifts, or a // single reduction. We have to be careful about states // with a single reduction: even though such a state is // not inconsistent (there is only one possible course of // action), we still want to run the lane table algorithm, // because otherwise we get states with "complete" // lookahead, which messes with error recovery. // // In particular, if there is too much lookahead, we will // reduce even when it is inappropriate to do so. actions = states[inconsistent_state.0] .reductions .iter() .map(|&(_, prod)| Action::Reduce(prod)) .collect(); if actions.is_empty() { return Ok(()); } } debug!("resolve_inconsistencies: conflicting_actions={:?}", actions); let table = self.build_lane_table(states, inconsistent_state, &actions); // Consider first the "LALR" case, where the lookaheads for each // action are completely disjoint. if self.attempt_lalr(&mut states[inconsistent_state.0], &table, &actions) { return Ok(()); } // Construct the initial states; each state will map to a // context-set derived from its row in the lane-table. This is // fallible, because a state may be internally inconstent. // // (To handle unification, we also map each state to a // `StateSet` that is its entry in the `ena` table.) let rows = table.rows()?; let mut unify = InPlaceUnificationTable::::new(); let mut state_sets = Map::new(); for (&state_index, context_set) in &rows { let state_set = unify.new_key(context_set.clone()); state_sets.insert(state_index, state_set); debug!( "resolve_inconsistencies: state_index={:?}, state_set={:?}", state_index, state_set ); } // Now merge state-sets, cloning states where needed. let mut merge = Merge::new( &table, &mut unify, states, &mut state_sets, inconsistent_state, ); let beachhead_states = table.beachhead_states(); for beachhead_state in beachhead_states { match merge.start(beachhead_state) { Ok(()) => {} Err((source, _)) => { debug!( "resolve_inconsistencies: failed to merge, source={:?}", source ); return Err(source); } } } merge.patch_target_starts(&actions); Ok(()) } fn attempt_lalr( &self, state: &mut LR1State<'grammar>, table: &LaneTable<'grammar>, actions: &Set>, ) -> bool { match table.columns() { Ok(columns) => { debug!("attempt_lalr, columns={:#?}", columns); columns.apply(state, actions); debug!("attempt_lalr, state={:#?}", state); true } Err(OverlappingLookahead) => { debug!("attempt_lalr, OverlappingLookahead"); false } } } fn build_lane_table( &self, states: &[LR1State<'grammar>], inconsistent_state: StateIndex, actions: &Set>, ) -> LaneTable<'grammar> { let state_graph = StateGraph::new(states); let mut tracer = LaneTracer::new( self.grammar, self.start_nt.clone(), states, &self.first_sets, &state_graph, actions.len(), ); for (i, action) in actions.iter().enumerate() { tracer.start_trace(inconsistent_state, ConflictIndex::new(i), action.clone()); } tracer.into_table() } } lalrpop-0.17.2/src/lr1/lane_table/construct/state_set.rs000064400000000000000000000030051341573331700214050ustar0000000000000000use ena::unify::{UnifyKey, UnifyValue}; use lr1::lane_table::table::context_set::{ContextSet, OverlappingLookahead}; /// The unification key for a set of states in the lane table /// algorithm. Each set of states is associated with a /// `ContextSet`. When two sets of states are merged, their conflict /// sets are merged as well; this will fail if that would produce an /// overlapping conflict set. #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub struct StateSet { index: u32, } impl UnifyKey for StateSet { type Value = ContextSet; fn index(&self) -> u32 { self.index } fn from_index(u: u32) -> Self { StateSet { index: u } } fn tag() -> &'static str { "StateSet" } } // FIXME: The `ena` interface is really designed around `UnifyValue` // being cheaply cloneable; we should either refactor `ena` a bit or // find some other way to associate a `ContextSet` with a state set // (for example, we could have each state set be associated with an // index that maps to a `ContextSet`), and do the merging ourselves. // But this is easier for now, and cloning a `ContextSet` isn't THAT // expensive, right? :) impl UnifyValue for ContextSet { type Error = (Self, Self); fn unify_values(value1: &Self, value2: &Self) -> Result { match ContextSet::union(value1, value2) { Ok(v) => Ok(v), Err(OverlappingLookahead) => Err((value1.clone(), value2.clone())), } } } lalrpop-0.17.2/src/lr1/lane_table/lane/mod.rs000064400000000000000000000124601346406170700170720ustar0000000000000000//! Code to trace out a single lane, collecting information into the //! lane table as we go. use collections::Set; use grammar::repr::*; use lr1::core::*; use lr1::first::FirstSets; use lr1::lookahead::*; use lr1::state_graph::StateGraph; use super::table::{ConflictIndex, LaneTable}; pub struct LaneTracer<'trace, 'grammar: 'trace, L: Lookahead + 'trace> { states: &'trace [State<'grammar, L>], first_sets: &'trace FirstSets, state_graph: &'trace StateGraph, table: LaneTable<'grammar>, start_nt: NonterminalString, } impl<'trace, 'grammar, L: Lookahead> LaneTracer<'trace, 'grammar, L> { pub fn new( grammar: &'grammar Grammar, start_nt: NonterminalString, states: &'trace [State<'grammar, L>], first_sets: &'trace FirstSets, state_graph: &'trace StateGraph, conflicts: usize, ) -> Self { LaneTracer { states, first_sets, state_graph, start_nt, table: LaneTable::new(grammar, conflicts), } } pub fn into_table(self) -> LaneTable<'grammar> { self.table } pub fn start_trace( &mut self, state: StateIndex, conflict: ConflictIndex, action: Action<'grammar>, ) { let mut visited_set = Set::default(); // if the conflict item is a "shift" item, then the context // is always the terminal to shift (and conflicts only arise // around shifting terminal, so it must be a terminal) match action { Action::Shift(term, _) => { let mut token_set = TokenSet::new(); token_set.insert(Token::Terminal(term)); self.table.add_lookahead(state, conflict, &token_set); } Action::Reduce(prod) => { let item = Item::lr0(prod, prod.symbols.len()); self.continue_trace(state, conflict, item, &mut visited_set); } } } fn continue_trace( &mut self, state: StateIndex, conflict: ConflictIndex, item: LR0Item<'grammar>, visited: &mut Set<(StateIndex, LR0Item<'grammar>)>, ) { if !visited.insert((state, item)) { return; } if item.index > 0 { // This item was reached by shifting some symbol. We need // to unshift that symbol, which means we walk backwards // to predecessors of `state` in the state graph. // // Example: // // X = ...p T (*) ...s // // Here we would be "unshifting" T, which means we will // walk to predecessors of the current state that were // reached by shifting T. Those predecessors will contain // an item like `X = ...p (*) T ...s`, which we will then // process in turn. let shifted_symbol = item.production.symbols[item.index - 1].clone(); let unshifted_item = Item { index: item.index - 1, ..item }; let predecessors = self.state_graph.predecessors(state, shifted_symbol); for predecessor in predecessors { self.table.add_successor(predecessor, state); self.continue_trace(predecessor, conflict, unshifted_item, visited); } return; } // Either: we are in the start state, or this item was // reached by an epsilon transition. We have to // "unepsilon", which means that we search elsewhere in // the state for where the epsilon transition could have // come from. // // Example: // // X = (*) ... // // We will search for other items in the same state like: // // Y = ...p (*) X ...s // // We can then insert `FIRST(...s)` as lookahead for // `conflict`. If `...s` may derive epsilon, though, we // have to recurse and search with the previous item. let state_items = &self.states[state.0].items.vec; let nonterminal = &item.production.nonterminal; if *nonterminal == self.start_nt { // as a special case, if the `X` above is the special, synthetic // start-terminal, then the only thing that comes afterwards is EOF. self.table.add_lookahead(state, conflict, &TokenSet::eof()); } // NB: Under the normal LR terms, the start nonterminal will // only have one production like `X' = X`, in which case this // loop is useless, but sometimes in tests we don't observe // that restriction, so do it anyway. for pred_item in state_items .iter() .filter(|i| i.can_shift_nonterminal(nonterminal)) { let symbol_sets = pred_item.symbol_sets(); let mut first = self.first_sets.first0(symbol_sets.suffix); let derives_epsilon = first.take_eof(); self.table.add_lookahead(state, conflict, &first); if derives_epsilon { self.continue_trace(state, conflict, pred_item.to_lr0(), visited); } } } } lalrpop-0.17.2/src/lr1/lane_table/mod.rs000064400000000000000000000013121341573331700161440ustar0000000000000000use collections::Set; use grammar::repr::*; use lr1::core::*; use lr1::lookahead::Lookahead; mod construct; mod lane; mod table; #[cfg(test)] mod test; pub fn build_lane_table_states<'grammar>( grammar: &'grammar Grammar, start: NonterminalString, ) -> LR1Result<'grammar> { construct::LaneTableConstruct::new(grammar, start).construct() } fn conflicting_actions<'grammar, L: Lookahead>( state: &State<'grammar, L>, ) -> Set> { let conflicts = L::conflicts(state); let reductions = conflicts.iter().map(|c| Action::Reduce(c.production)); let actions = conflicts.iter().map(|c| c.action.clone()); reductions.chain(actions).collect() } lalrpop-0.17.2/src/lr1/lane_table/table/context_set/mod.rs000064400000000000000000000062731346406170700216060ustar0000000000000000//! A key part of the lane-table algorithm is the idea of a CONTEXT //! SET (my name, the paper has no name for this). Basically it //! represents the LR1 context under which a given conflicting action //! would take place. //! //! So, for example, imagine this grammar: //! //! ```notrust //! A = B x //! | C y //! B = z //! C = z //! ``` //! //! This gives rise to states like: //! //! - `S0 = { * B x, * C y, B = * z, C = * z }` //! - `S1 = { B = z *, C = z * }` //! //! This second state has two conflicting items. Let's call them //! conflicts 0 and 1 respectively. The conflict set would then have //! two entries (one for each conflict) and it would map each of them //! to a TokenSet supplying context. So when we trace everything //! out we might get a ContextSet of: //! //! - `[ 0: x, 1: y ]` //! //! In general, you want to ensure that the token sets of all //! conflicting items are pairwise-disjoint, or else if you get to a //! state that has both of those items (which, by definition, does //! arise) you won't know which to take. In this case, we're all set, //! because item 0 occurs only with lookahead `x` and item 1 with //! lookahead `y`. use collections::{Map, Set}; use lr1::core::*; use lr1::lookahead::*; mod test; use super::ConflictIndex; #[derive(Clone, Debug)] pub struct ContextSet { values: Vec, } #[derive(Debug)] pub struct OverlappingLookahead; impl ContextSet { pub fn new(num_conflicts: usize) -> Self { ContextSet { values: (0..num_conflicts).map(|_| TokenSet::new()).collect(), } } pub fn union(set1: &ContextSet, set2: &ContextSet) -> Result { let mut result = set1.clone(); for (i, t) in set2.values.iter().enumerate() { result.insert(ConflictIndex::new(i), t)?; } Ok(result) } /// Attempts to merge the values `conflict: set` into this /// conflict set. If this would result in an invalid conflict set /// (where two conflicts have overlapping lookahead), then returns /// `Err(OverlappingLookahead)` and has no effect. /// /// Assuming no errors, returns `Ok(true)` if this resulted in any /// modifications, and `Ok(false)` otherwise. pub fn insert( &mut self, conflict: ConflictIndex, set: &TokenSet, ) -> Result { for (value, index) in self.values.iter().zip((0..).map(ConflictIndex::new)) { if index != conflict && value.is_intersecting(&set) { return Err(OverlappingLookahead); } } Ok(self.values[conflict.index].union_with(&set)) } pub fn apply<'grammar>(&self, state: &mut LR1State<'grammar>, actions: &Set>) { // create a map from each action to its lookahead let lookaheads: Map, &TokenSet> = actions.iter().cloned().zip(&self.values).collect(); for &mut (ref mut lookahead, production) in &mut state.reductions { let action = Action::Reduce(production); *lookahead = lookaheads[&action].clone(); } } } lalrpop-0.17.2/src/lr1/lane_table/table/context_set/test.rs000064400000000000000000000000171341573331700217730ustar0000000000000000#![cfg(test)] lalrpop-0.17.2/src/lr1/lane_table/table/mod.rs000064400000000000000000000162041346406170700172420ustar0000000000000000//! The "Lane Table". In the paper, this is depicted like so: //! //! ``` //! +-------+----+-----+----+------------+ //! + State | C1 | ... | Cn | Successors | //! +-------+----+-----+----+------------+ //! ``` //! //! where each row summarizes some state that potentially contributes //! lookahead to the conflict. The columns `Ci` represent each of the //! conflicts we are trying to disentangle; their values are each //! `TokenSet` indicating the lookahead contributing by this state. //! The Successors is a vector of further successors. For simplicity //! though we store this using maps, at least for now. use collections::{Map, Multimap, Set}; use grammar::repr::*; use lr1::core::*; use lr1::lookahead::*; use std::default::Default; use std::fmt::{Debug, Error, Formatter}; use std::iter; pub mod context_set; use self::context_set::{ContextSet, OverlappingLookahead}; #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)] pub struct ConflictIndex { index: usize, } impl ConflictIndex { pub fn new(index: usize) -> ConflictIndex { ConflictIndex { index } } } pub struct LaneTable<'grammar> { _grammar: &'grammar Grammar, conflicts: usize, lookaheads: Map<(StateIndex, ConflictIndex), TokenSet>, successors: Multimap>, } impl<'grammar> LaneTable<'grammar> { pub fn new(grammar: &'grammar Grammar, conflicts: usize) -> LaneTable { LaneTable { _grammar: grammar, conflicts, lookaheads: Map::default(), successors: Multimap::default(), } } pub fn add_lookahead(&mut self, state: StateIndex, conflict: ConflictIndex, tokens: &TokenSet) { self.lookaheads .entry((state, conflict)) .or_insert_with(TokenSet::new) .union_with(&tokens); } pub fn add_successor(&mut self, state: StateIndex, succ: StateIndex) { self.successors.push(state, succ); } /// Unions together the lookaheads for each column and returns a /// context set containing all of them. For an LALR(1) grammar, /// these token sets will be mutually disjoint, as discussed in /// the [README]; otherwise `Err` will be returned. /// /// [README]: ../README.md pub fn columns(&self) -> Result { let mut columns = ContextSet::new(self.conflicts); for (&(_, conflict_index), set) in &self.lookaheads { columns.insert(conflict_index, set)?; } Ok(columns) } pub fn successors(&self, state: StateIndex) -> Option<&Set> { self.successors.get(&state) } /// Returns the state of states in the table that are **not** /// reachable from another state in the table. These are called /// "beachhead states". pub fn beachhead_states(&self) -> Set { // set of all states that are reachable from another state let reachable: Set = self .successors .iter() .flat_map(|(_pred, succ)| succ) .cloned() .collect(); self.lookaheads .keys() .map(|&(state_index, _)| state_index) .filter(|s| !reachable.contains(s)) .collect() } pub fn context_set(&self, state: StateIndex) -> Result { let mut set = ContextSet::new(self.conflicts); for (&(state_index, conflict_index), token_set) in &self.lookaheads { if state_index == state { set.insert(conflict_index, token_set)?; } } Ok(set) } /// Returns a map containing all states that appear in the table, /// along with the context set for each state (i.e., each row in /// the table, basically). Returns Err if any state has a conflict /// between the context sets even within its own row. pub fn rows(&self) -> Result, StateIndex> { let mut map = Map::new(); for (&(state_index, conflict_index), token_set) in &self.lookaheads { debug!( "rows: inserting state_index={:?} conflict_index={:?} token_set={:?}", state_index, conflict_index, token_set ); match { map.entry(state_index) .or_insert_with(|| ContextSet::new(self.conflicts)) .insert(conflict_index, token_set) } { Ok(_changed) => {} Err(OverlappingLookahead) => { debug!("rows: intra-row conflict inserting state_index={:?} conflict_index={:?} token_set={:?}", state_index, conflict_index, token_set); return Err(state_index); } } } // In some cases, there are states that have no context at // all, only successors. In that case, make sure to add an // empty row for them. for (&state_index, _) in &self.successors { map.entry(state_index) .or_insert_with(|| ContextSet::new(self.conflicts)); } Ok(map) } } impl<'grammar> Debug for LaneTable<'grammar> { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { let indices: Set = self .lookaheads .keys() .map(|&(state, _)| state) .chain(self.successors.iter().map(|(&key, _)| key)) .collect(); let header = iter::once("State".to_string()) .chain((0..self.conflicts).map(|i| format!("C{}", i))) .chain(Some("Successors".to_string())) .collect(); let rows = indices.iter().map(|&index| { iter::once(format!("{:?}", index)) .chain((0..self.conflicts).map(|i| { self.lookaheads .get(&(index, ConflictIndex::new(i))) .map(|token_set| format!("{:?}", token_set)) .unwrap_or_else(String::new) })) .chain(Some( self.successors .get(&index) .map(|c| format!("{:?}", c)) .unwrap_or_else(String::new), )) .collect() }); let table: Vec> = iter::once(header).chain(rows).collect(); let columns = 2 + self.conflicts; let widths: Vec<_> = (0..columns) .map(|c| { // find the max width of any row at this column table.iter().map(|r| r[c].len()).max().unwrap() }) .collect(); for row in &table { write!(fmt, "| ")?; for (i, column) in row.iter().enumerate() { if i > 0 { write!(fmt, " | ")?; } write!(fmt, "{0:1$}", column, widths[i])?; } writeln!(fmt, " |")?; } Ok(()) } } lalrpop-0.17.2/src/lr1/lane_table/test.rs000064400000000000000000000251111346406170700163500ustar0000000000000000use grammar::repr::*; use lr1::build; use lr1::core::*; use lr1::first::FirstSets; use lr1::interpret; use lr1::state_graph::StateGraph; use lr1::tls::Lr1Tls; use string_cache::DefaultAtom as Atom; use test_util::{expect_debug, normalized_grammar}; use tls::Tls; use super::construct::*; use super::lane::*; use super::table::*; macro_rules! tokens { ($($x:expr),*) => { vec![$(TerminalString::quoted(Atom::from($x))),*] } } fn sym(t: &str) -> Symbol { if t.chars().next().unwrap().is_uppercase() { Symbol::Nonterminal(nt(t)) } else { Symbol::Terminal(term(t)) } } fn term(t: &str) -> TerminalString { TerminalString::quoted(Atom::from(t)) } fn nt(t: &str) -> NonterminalString { NonterminalString(Atom::from(t)) } fn traverse(states: &[LR0State], tokens: &[&str]) -> StateIndex { interpret::interpret_partial(states, tokens.iter().map(|&s| term(s))) .unwrap() .pop() .unwrap() } /// A simplified version of the paper's initial grammar; this version /// only has one inconsistent state (the same state they talk about in /// the paper). pub fn paper_example_g0() -> Grammar { normalized_grammar( r#" grammar; pub G: () = { X "c", Y "d", }; X: () = { "e" X, "e",} ; Y: () = { "e" Y, "e" }; "#, ) } /// A (corrected) version of the sample grammar G1 from the paper. The /// grammar as written in the text omits some items, but the diagrams /// seem to contain the full set. I believe this is one of the /// smallest examples that still requires splitting states from the /// LR0 states. pub fn paper_example_g1() -> Grammar { normalized_grammar( r#" grammar; pub G: () = { // if "a" is input, then lookahead "d" means "reduce X" // and lookahead "c" means "reduce "Y" "a" X "d", "a" Y "c", // if "b" is input, then lookahead "d" means "reduce Y" // and lookahead "c" means "reduce X. "b" X "c", "b" Y "d", }; X: () = { "e" X, "e", }; Y: () = { "e" Y, "e" }; "#, ) } fn build_table<'grammar>( grammar: &'grammar Grammar, goal: &str, tokens: &[&str], ) -> LaneTable<'grammar> { let lr0_err = build::build_lr0_states(&grammar, nt(goal)).unwrap_err(); // Push the `tokens` to find the index of the inconsistent state let inconsistent_state_index = traverse(&lr0_err.states, tokens); assert!(lr0_err .conflicts .iter() .any(|c| c.state == inconsistent_state_index)); let inconsistent_state = &lr0_err.states[inconsistent_state_index.0]; println!("inconsistent_state={:#?}", inconsistent_state.items); // Extract conflicting items and trace the lanes, constructing a table let conflicting_items = super::conflicting_actions(inconsistent_state); println!("conflicting_items={:#?}", conflicting_items); let first_sets = FirstSets::new(&grammar); let state_graph = StateGraph::new(&lr0_err.states); let mut tracer = LaneTracer::new( &grammar, nt("G"), &lr0_err.states, &first_sets, &state_graph, conflicting_items.len(), ); for (i, conflicting_item) in conflicting_items.iter().enumerate() { tracer.start_trace( inconsistent_state.index, ConflictIndex::new(i), conflicting_item.clone(), ); } tracer.into_table() } #[test] fn g0_conflict_1() { let _tls = Tls::test(); let grammar = paper_example_g0(); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let table = build_table(&grammar, "G", &["e"]); println!("{:#?}", table); // conflicting_actions={ // Shift("e") // C0 // Reduce(X = "e" => ActionFn(4)) // C1 // Reduce(Y = "e" => ActionFn(6)) // C2 // } expect_debug( &table, r#" | State | C0 | C1 | C2 | Successors | | S0 | | ["c"] | ["d"] | {S3} | | S3 | ["e"] | [] | [] | {S3} | "# .trim_start(), ); } #[test] fn paper_example_g1_conflict_1() { let _tls = Tls::test(); let grammar = paper_example_g1(); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let table = build_table(&grammar, "G", &["a", "e"]); println!("{:#?}", table); // conflicting_actions={ // Shift("e") // C0 // Reduce(X = "e" => ActionFn(6)) // C1 // Reduce(Y = "e" => ActionFn(8)) // C2 // } expect_debug( &table, r#" | State | C0 | C1 | C2 | Successors | | S1 | | ["d"] | ["c"] | {S5} | | S2 | | ["c"] | ["d"] | {S5} | | S5 | ["e"] | [] | [] | {S5} | "# .trim_start(), ); } #[test] fn paper_example_g0_build() { let _tls = Tls::test(); let grammar = paper_example_g0(); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let lr0_err = build::build_lr0_states(&grammar, nt("G")).unwrap_err(); let states = LaneTableConstruct::new(&grammar, nt("G")) .construct() .expect("failed to build lane table states"); // we do not require more *states* than LR(0), just different lookahead assert_eq!(states.len(), lr0_err.states.len()); let tree = interpret::interpret(&states, tokens!["e", "c"]).unwrap(); expect_debug(&tree, r#"[G: [X: "e"], "c"]"#); let tree = interpret::interpret(&states, tokens!["e", "e", "c"]).unwrap(); expect_debug(&tree, r#"[G: [X: "e", [X: "e"]], "c"]"#); let tree = interpret::interpret(&states, tokens!["e", "e", "d"]).unwrap(); expect_debug(&tree, r#"[G: [Y: "e", [Y: "e"]], "d"]"#); interpret::interpret(&states, tokens!["e", "e", "e"]).unwrap_err(); } #[test] fn paper_example_g1_build() { let _tls = Tls::test(); let grammar = paper_example_g1(); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let lr0_err = build::build_lr0_states(&grammar, nt("G")).unwrap_err(); let states = LaneTableConstruct::new(&grammar, nt("G")) .construct() .expect("failed to build lane table states"); // we require more *states* than LR(0), not just different lookahead assert_eq!(states.len() - lr0_err.states.len(), 1); let tree = interpret::interpret(&states, tokens!["a", "e", "e", "d"]).unwrap(); expect_debug(&tree, r#"[G: "a", [X: "e", [X: "e"]], "d"]"#); let tree = interpret::interpret(&states, tokens!["b", "e", "e", "d"]).unwrap(); expect_debug(&tree, r#"[G: "b", [Y: "e", [Y: "e"]], "d"]"#); interpret::interpret(&states, tokens!["e", "e", "e"]).unwrap_err(); } pub fn paper_example_large() -> Grammar { normalized_grammar( r#" grammar; pub G: () = { "x" W "a", "x" V "t", "y" W "b", "y" V "t", "z" W "r", "z" V "b", "u" U X "a", "u" U Y "r", }; W: () = { U X C }; V: () = { U Y "d" }; X: () = { "k" "t" U X P, "k" "t" }; Y: () = { "k" "t" U Y "u", "k" "t" }; U: () = { U "k" "t", "s" }; E: () = { "a", "b", "c", "v", }; C: () = { "c", "w" }; P: () = { "z" }; "#, ) } #[test] fn large_conflict_1() { let _tls = Tls::test(); let grammar = paper_example_large(); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let table = build_table(&grammar, "G", &["x", "s", "k", "t"]); println!("{:#?}", table); // conflicting_actions={ // Shift("s") // C0 // Reduce(U = U "k" "t") // C1 // Reduce(X = "k" "t") // C2 // Reduce(Y = "k" "t") // C3 // } expect_debug( &table, r#" | State | C0 | C1 | C2 | C3 | Successors | | S1 | | ["k"] | | | {S5} | | S2 | | ["k"] | | | {S7} | | S3 | | ["k"] | | | {S7} | | S4 | | ["k"] | | | {S7} | | S5 | | | ["a"] | ["r"] | {S16} | | S7 | | | ["c", "w"] | ["d"] | {S16} | | S16 | | | | | {S27} | | S27 | ["s"] | ["k"] | | | {S32} | | S32 | | | ["z"] | ["u"] | {S16} | "# .trim_start(), ); // ^^ This differs in some particulars from what appears in the // paper, but I believe it to be correct, and the paper to be wrong. // // Here is the table using the state names from the paper. I've // marked the differences with `(*)`. Note that the paper does not // include the C0 column (the shift). // // | State | pi1 | pi2 | pi3 | Successors | // | B | ["k"] | | *1 | {G} | // | C | ["k"] | | *1 | {G} | // | D | ["k"] | | *1 | {G} | // | E | ["k"] | | | {F} | // | F | | ["r"] | ["a"] | {H} | // | G | | ["d"] | ["c", "w"] | {H} | // | H | | | | {I} | // | I | ["k"] | | | {J} | // | J | | ["u"] | ["z"] *2 | {H} | // // *1 - the paper lists "a", "b", and "r" here as lookaheads. We // do not. This is because when we trace back pi3, we never reach // those states, as we have already acquired the necessary token // of context earlier. I can imagine a distinct lane tracing // algorithm that considers *sets* of conflicts and only // terminates when all sets have context, but it's much more // complex to implement, and seems to add little value. // // *2 - the paper does not list this context, and yet it seems to // present. If you trace back "t" and "k" you reach state J which // has the item "X = k t (*)". This "unepsilons" to "X = k t U (*) // X P", and the lookahead from the "X" here is FIRST(P) which is // "z". } #[test] fn paper_example_large_build() { let _tls = Tls::test(); let grammar = paper_example_large(); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let states = LaneTableConstruct::new(&grammar, nt("G")) .construct() .expect("failed to build lane table states"); let tree = interpret::interpret(&states, tokens!["y", "s", "k", "t", "c", "b"]).unwrap(); expect_debug( &tree, r#"[G: "y", [W: [U: "s"], [X: "k", "t"], [C: "c"]], "b"]"#, ); } lalrpop-0.17.2/src/lr1/lookahead.rs000064400000000000000000000206121346406170700152330ustar0000000000000000use bit_set::{self, BitSet}; use collections::Collection; use grammar::repr::*; use lr1::core::*; use lr1::tls::Lr1Tls; use std::fmt::{Debug, Error, Formatter}; use std::hash::Hash; pub trait Lookahead: Clone + Debug + Eq + Ord + Hash + Collection { fn fmt_as_item_suffix(&self, fmt: &mut Formatter) -> Result<(), Error>; fn conflicts<'grammar>(this_state: &State<'grammar, Self>) -> Vec>; } #[derive(Copy, Clone, Debug, Default, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct Nil; impl Collection for Nil { type Item = Nil; fn push(&mut self, _: Nil) -> bool { false } } impl Lookahead for Nil { fn fmt_as_item_suffix(&self, _fmt: &mut Formatter) -> Result<(), Error> { Ok(()) } fn conflicts<'grammar>(this_state: &State<'grammar, Self>) -> Vec> { let index = this_state.index; let mut conflicts = vec![]; for (terminal, &next_state) in &this_state.shifts { conflicts.extend( this_state .reductions .iter() .map(|&(_, production)| Conflict { state: index, lookahead: Nil, production, action: Action::Shift(terminal.clone(), next_state), }), ); } if this_state.reductions.len() > 1 { for &(_, production) in &this_state.reductions[1..] { let other_production = this_state.reductions[0].1; conflicts.push(Conflict { state: index, lookahead: Nil, production, action: Action::Reduce(other_production), }); } } conflicts } } /// I have semi-arbitrarily decided to use the term "token" to mean /// either one of the terminals of our language, or else the /// pseudo-symbol EOF that represents "end of input". #[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] pub enum Token { EOF, Error, Terminal(TerminalString), } impl Lookahead for TokenSet { fn fmt_as_item_suffix(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, " {:?}", self) } fn conflicts<'grammar>(this_state: &State<'grammar, Self>) -> Vec> { let mut conflicts = vec![]; for (terminal, &next_state) in &this_state.shifts { let token = Token::Terminal(terminal.clone()); let inconsistent = this_state .reductions .iter() .filter_map(|&(ref reduce_tokens, production)| { if reduce_tokens.contains(&token) { Some(production) } else { None } }); let set = TokenSet::from(token.clone()); for production in inconsistent { conflicts.push(Conflict { state: this_state.index, lookahead: set.clone(), production, action: Action::Shift(terminal.clone(), next_state), }); } } let len = this_state.reductions.len(); for i in 0..len { for j in i + 1..len { let &(ref i_tokens, i_production) = &this_state.reductions[i]; let &(ref j_tokens, j_production) = &this_state.reductions[j]; if i_tokens.is_disjoint(j_tokens) { continue; } conflicts.push(Conflict { state: this_state.index, lookahead: i_tokens.intersection(j_tokens), production: i_production, action: Action::Reduce(j_production), }); } } conflicts } } impl Token { pub fn unwrap_terminal(&self) -> &TerminalString { match *self { Token::Terminal(ref t) => t, Token::EOF | Token::Error => { panic!("`unwrap_terminal()` invoked but with EOF or Error") } } } } #[derive(Clone, Default, Hash, PartialEq, Eq, PartialOrd, Ord)] pub struct TokenSet { bit_set: BitSet, } fn with(op: OP) -> RET where OP: FnOnce(&TerminalSet) -> RET, { Lr1Tls::with(op) } impl TokenSet { pub fn new() -> Self { with(|terminals| TokenSet { bit_set: BitSet::with_capacity(terminals.all.len() + 2), }) } /// A TokenSet containing all possible terminals + EOF. pub fn all() -> Self { let mut s = TokenSet::new(); with(|terminals| { for i in 0..terminals.all.len() { s.bit_set.insert(i); } s.insert_eof(); }); s } pub fn eof() -> Self { let mut set = TokenSet::new(); set.insert_eof(); set } fn eof_bit(&self) -> usize { with(|terminals| terminals.all.len()) } fn bit(&self, lookahead: &Token) -> usize { match *lookahead { Token::EOF => self.eof_bit(), Token::Error => self.eof_bit() + 1, Token::Terminal(ref t) => with(|terminals| terminals.bits[t]), } } pub fn len(&self) -> usize { self.bit_set.len() } pub fn insert(&mut self, lookahead: Token) -> bool { let bit = self.bit(&lookahead); self.bit_set.insert(bit) } pub fn insert_eof(&mut self) -> bool { let bit = self.eof_bit(); self.bit_set.insert(bit) } pub fn union_with(&mut self, set: &TokenSet) -> bool { let len = self.len(); self.bit_set.union_with(&set.bit_set); self.len() != len } pub fn intersection(&self, set: &TokenSet) -> TokenSet { let mut bit_set = self.bit_set.clone(); bit_set.intersect_with(&set.bit_set); TokenSet { bit_set } } pub fn contains(&self, token: &Token) -> bool { self.bit_set.contains(self.bit(token)) } pub fn contains_eof(&self) -> bool { self.bit_set.contains(self.eof_bit()) } /// If this set contains EOF, removes it from the set and returns /// true. Otherwise, returns false. pub fn take_eof(&mut self) -> bool { let eof_bit = self.eof_bit(); let contains_eof = self.bit_set.contains(eof_bit); self.bit_set.remove(eof_bit); contains_eof } pub fn is_disjoint(&self, other: &TokenSet) -> bool { self.bit_set.is_disjoint(&other.bit_set) } pub fn is_intersecting(&self, other: &TokenSet) -> bool { !self.is_disjoint(other) } pub fn iter(&self) -> TokenSetIter<'_> { TokenSetIter { bit_set: self.bit_set.iter(), } } } pub struct TokenSetIter<'iter> { bit_set: bit_set::Iter<'iter, u32>, } impl<'iter> Iterator for TokenSetIter<'iter> { type Item = Token; fn next(&mut self) -> Option { self.bit_set.next().map(|bit| { with(|terminals| { if bit == terminals.all.len() + 1 { Token::Error } else if bit == terminals.all.len() { Token::EOF } else { Token::Terminal(terminals.all[bit].clone()) } }) }) } } impl<'debug> Debug for TokenSet { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { let terminals: Vec<_> = self.iter().collect(); Debug::fmt(&terminals, fmt) } } impl<'iter> IntoIterator for &'iter TokenSet { type IntoIter = TokenSetIter<'iter>; type Item = Token; fn into_iter(self) -> Self::IntoIter { self.iter() } } impl Collection for TokenSet { type Item = TokenSet; fn push(&mut self, item: TokenSet) -> bool { self.union_with(&item) } } impl From for TokenSet { fn from(token: Token) -> Self { let mut set = TokenSet::new(); set.insert(token); set } } lalrpop-0.17.2/src/lr1/mod.rs000064400000000000000000000016261341573331700140660ustar0000000000000000//! Naive LR(1) generation algorithm. use grammar::repr::*; mod build; mod build_lalr; pub mod codegen; mod core; mod error; mod example; mod first; mod lane_table; mod lookahead; mod report; mod state_graph; mod tls; mod trace; use std::io::{self, Write}; #[cfg(test)] mod interpret; pub use self::core::{LR1Result, LR1TableConstructionError}; pub use self::error::report_error; pub use self::tls::Lr1Tls; pub fn build_states<'grammar>( grammar: &'grammar Grammar, start: NonterminalString, ) -> LR1Result<'grammar> { if !grammar.algorithm.lalr { build::build_lr1_states(grammar, start) } else { build_lalr::build_lalr_states(grammar, start) } } pub fn generate_report<'grammar, W: Write + 'grammar>( out: &'grammar mut W, lr1result: &LR1Result<'grammar>, ) -> io::Result<()> { report::generate_report(out, lr1result) } lalrpop-0.17.2/src/lr1/report/mod.rs000064400000000000000000000306071346406170700154030ustar0000000000000000use collections::*; use grammar::repr::*; use lr1::core::*; use std::cmp::max; use std::io::{self, Write}; use super::lookahead::*; pub fn generate_report<'grammar, W: Write + 'grammar>( out: &'grammar mut W, lr1result: &LR1Result<'grammar>, ) -> io::Result<()> { let mut generator = ReportGenerator::new(out); generator.report_lr_table_construction(lr1result) } static INDENT_STRING: &'static str = " "; struct ReportGenerator<'report, W> where W: Write + 'report, { pub out: &'report mut W, } type ConflictStateMap<'report, 'grammar, L> = Map>>; impl<'report, W> ReportGenerator<'report, W> where W: Write + 'report, { pub fn new(out: &'report mut W) -> Self { ReportGenerator { out } } pub fn report_lr_table_construction<'grammar: 'report, L>( &mut self, lr1result: &'report LRResult<'grammar, L>, ) -> io::Result<()> where L: Lookahead + LookaheadPrinter, { self.write_header()?; self.write_section_header("Summary")?; writeln!(self.out)?; match lr1result { Ok(ref states) => { writeln!(self.out, "Constructed {} states", states.len())?; self.report_states(&states, &Map::new())?; } Err(ref table_construction_error) => { writeln!(self.out, "Failure")?; writeln!( self.out, "Constructed {} states", table_construction_error.states.len() )?; writeln!( self.out, "Has {} conflicts", table_construction_error.conflicts.len() )?; let (sr, rr, conflict_map) = self.process_conflicts(&table_construction_error.conflicts); if (sr > 0) { writeln!(self.out, "{}shift/reduce: {}", INDENT_STRING, sr)?; } if (rr > 0) { writeln!(self.out, "{}reduce/reduce: {}", INDENT_STRING, rr)?; } write!(self.out, "States with conflicts: ")?; for state in conflict_map.keys() { write!(self.out, " {}", state)?; } writeln!(self.out)?; self.report_states(&table_construction_error.states, &conflict_map)?; } }; Ok(()) } fn process_conflicts<'grammar, L>( &mut self, conflicts: &'report [Conflict<'grammar, L>], ) -> (usize, usize, ConflictStateMap<'report, 'grammar, L>) where L: Lookahead, { let mut sr: usize = 0; let mut rr: usize = 0; let mut conflict_map = Map::new(); for conflict in conflicts.iter() { match conflict.action { Action::Shift(..) => sr += 1, Action::Reduce(_) => rr += 1, } conflict_map .entry(conflict.state) .or_insert_with(Vec::new) .push(conflict); } (sr, rr, conflict_map) } fn report_states<'grammar, L>( &mut self, states: &[State<'grammar, L>], conflict_map: &ConflictStateMap<'report, 'grammar, L>, ) -> io::Result<()> where L: Lookahead + LookaheadPrinter, { self.write_section_header("State Table")?; for state in states { writeln!(self.out)?; self.report_state(&state, conflict_map.get(&state.index))?; } Ok(()) } fn report_state<'grammar, L>( &mut self, state: &State<'grammar, L>, conflicts_opt: Option<&Vec<&'report Conflict<'grammar, L>>>, ) -> io::Result<()> where L: Lookahead + LookaheadPrinter, { writeln!(self.out, "State {} {{", state.index)?; self.write_items(&state.items)?; if (!state.reductions.is_empty()) { writeln!(self.out)?; self.write_reductions(&state.reductions)?; } let max_width = get_width_for_gotos(state); if (!state.shifts.len() > 0) { writeln!(self.out)?; self.write_shifts(&state.shifts, max_width)?; } if (!state.gotos.len() > 0) { writeln!(self.out)?; self.write_gotos(&state.gotos, max_width)?; } if let Some(conflicts) = conflicts_opt { for conflict in conflicts.iter() { self.write_conflict(conflict)?; } } writeln!(self.out, "}}")?; Ok(()) } fn write_conflict<'grammar, L>(&mut self, conflict: &Conflict<'grammar, L>) -> io::Result<()> where L: Lookahead + LookaheadPrinter, { writeln!(self.out)?; match conflict.action { Action::Shift(ref terminal, state) => { let max_width = max( terminal.display_len(), conflict.production.nonterminal.len(), ); writeln!(self.out, "{}shift/reduce conflict", INDENT_STRING)?; write!(self.out, "{}{}reduction ", INDENT_STRING, INDENT_STRING)?; self.write_production(conflict.production, max_width)?; let sterminal = format!("{}", terminal); writeln!( self.out, "{}{}shift {:width$} shift and goto {}", INDENT_STRING, INDENT_STRING, sterminal, state, width = max_width )?; } Action::Reduce(other_production) => { let max_width = max( other_production.nonterminal.len(), conflict.production.nonterminal.len(), ); writeln!(self.out, "{}reduce/reduce conflict", INDENT_STRING)?; write!(self.out, "{}{}reduction ", INDENT_STRING, INDENT_STRING)?; self.write_production(conflict.production, max_width)?; write!(self.out, "{}{}reduction ", INDENT_STRING, INDENT_STRING)?; self.write_production(other_production, max_width)?; } } self.write_lookahead(&conflict.lookahead)?; Ok(()) } fn write_items<'grammar, L>(&mut self, items: &Items<'grammar, L>) -> io::Result<()> where L: Lookahead + LookaheadPrinter, { let max_width = get_max_length(items.vec.iter().map(|item| &item.production.nonterminal)); for item in items.vec.iter() { writeln!(self.out)?; self.write_item(item, max_width)?; } Ok(()) } fn write_item<'grammar, L>( &mut self, item: &Item<'grammar, L>, max_width: usize, ) -> io::Result<()> where L: Lookahead + LookaheadPrinter, { write!(self.out, "{}", INDENT_STRING)?; // stringize it first to allow handle :width by Display for string let s = format!("{}", item.production.nonterminal); write!(self.out, "{:width$} ->", s, width = max_width)?; for i in 0..item.index { write!(self.out, " {}", item.production.symbols[i])?; } write!(self.out, " .")?; for i in item.index..item.production.symbols.len() { write!(self.out, " {}", item.production.symbols[i])?; } writeln!(self.out)?; self.write_lookahead(&item.lookahead)?; Ok(()) } fn write_shifts( &mut self, shifts: &Map, max_width: usize, ) -> io::Result<()> { for entry in shifts { write!(self.out, "{}", INDENT_STRING)?; // stringize it first to allow handle :width by Display for string let s = format!("{}", entry.0); writeln!( self.out, "{:width$} shift and goto {}", s, entry.1, width = max_width )?; } Ok(()) } fn write_reductions<'grammar, L>( &mut self, reductions: &[(L, &'grammar Production)], ) -> io::Result<()> where L: Lookahead + LookaheadPrinter, { let max_width = get_max_length(reductions.iter().map(|p| &p.1.nonterminal)); for reduction in reductions.iter() { writeln!(self.out)?; self.write_reduction(reduction, max_width)?; } Ok(()) } fn write_production<'grammar>( &mut self, production: &'grammar Production, max_width: usize, ) -> io::Result<()> { write!( self.out, "{:width$} ->", production.nonterminal, width = max_width )?; for symbol in production.symbols.iter() { write!(self.out, " {}", symbol)?; } writeln!(self.out)?; Ok(()) } fn write_reduction<'grammar, L>( &mut self, reduction: &(L, &'grammar Production), max_width: usize, ) -> io::Result<()> where L: Lookahead + LookaheadPrinter, { let production = reduction.1; write!(self.out, "{}reduction ", INDENT_STRING)?; self.write_production(production, max_width)?; self.write_lookahead(&reduction.0)?; Ok(()) } fn write_lookahead(&mut self, lookahead: &L) -> io::Result<()> where L: Lookahead + LookaheadPrinter, { if (lookahead.has_anything_to_print()) { write!(self.out, "{}{}lookahead", INDENT_STRING, INDENT_STRING)?; lookahead.print(self.out)?; writeln!(self.out)?; } Ok(()) } fn write_gotos( &mut self, gotos: &Map, max_width: usize, ) -> io::Result<()> { for entry in gotos { write!(self.out, "{}", INDENT_STRING)?; // stringize it first to allow handle :width by Display for string let s = format!("{}", entry.0); writeln!(self.out, "{:width$} goto {}", s, entry.1, width = max_width)?; } Ok(()) } fn write_section_header(&mut self, title: &str) -> io::Result<()> { writeln!(self.out, "\n{}", title)?; writeln!(self.out, "----------------------------------------")?; Ok(()) } fn write_header(&mut self) -> io::Result<()> { writeln!(self.out, "Lalrpop Report File")?; writeln!(self.out, "========================================")?; Ok(()) } } // helpers trait LookaheadPrinter where W: Write, { fn print<'report>(self: &Self, out: &'report mut W) -> io::Result<()>; fn has_anything_to_print(self: &Self) -> bool; } impl LookaheadPrinter for Nil where W: Write, { fn print<'report>(self: &Self, _: &'report mut W) -> io::Result<()> { Ok(()) } fn has_anything_to_print(self: &Self) -> bool { false } } impl LookaheadPrinter for TokenSet where W: Write, { fn print<'report>(self: &Self, out: &'report mut W) -> io::Result<()> { for i in self.iter() { write!(out, " {}", i)? } Ok(()) } fn has_anything_to_print(self: &Self) -> bool { self.len() > 0 } } trait HasDisplayLen { fn display_len(&self) -> usize; } impl<'a> HasDisplayLen for &'a TerminalString { fn display_len(&self) -> usize { TerminalString::display_len(self) } } impl<'a> HasDisplayLen for &'a NonterminalString { fn display_len(&self) -> usize { self.len() } } fn get_max_length(m: I) -> usize where I: Iterator, I::Item: HasDisplayLen, { m.map(|k| k.display_len()).fold(0, max) } fn get_width_for_gotos<'grammar, L>(state: &State<'grammar, L>) -> usize where L: Lookahead, { let shifts_max_width = get_max_length(state.shifts.keys()); let gotos_max_width = get_max_length(state.gotos.keys()); max(shifts_max_width, gotos_max_width) } lalrpop-0.17.2/src/lr1/state_graph.rs000064400000000000000000000064201346406170700156060ustar0000000000000000use grammar::repr::*; use lr1::core::*; use lr1::lookahead::Lookahead; use petgraph::graph::NodeIndex; use petgraph::prelude::*; use petgraph::{EdgeDirection, Graph}; // Each state `s` corresponds to the node in the graph with index // `s`. The edges are the shift transitions. pub struct StateGraph { graph: Graph<(), Symbol>, } impl StateGraph { pub fn new<'grammar, L>(states: &[State<'grammar, L>]) -> StateGraph where L: Lookahead, { let mut graph = Graph::new(); // First, create the nodes. for i in 0..states.len() { let j = graph.add_node(()); assert_eq!(i, j.index()); } // Add in the edges. for (i, state) in states.iter().enumerate() { // Successors of a node arise from: // - shifts (found in the `conflicts` and `tokens` maps) // - gotos (found in the `gotos` map) graph.extend_with_edges( state .shifts .iter() .map(|(terminal, &state)| (Symbol::Terminal(terminal.clone()), state)) .chain( state .gotos .iter() .map(|(nt, &state)| (Symbol::Nonterminal(nt.clone()), state)), ) .map(|(symbol, successor)| { (NodeIndex::new(i), NodeIndex::new(successor.0), symbol) }), ); } StateGraph { graph } } /// Given a list of symbols `[X, Y, Z]`, traces back from /// `initial_state_index` to find the set of states whence we /// could have arrived at `initial_state_index` after pushing `X`, /// `Y`, and `Z`. pub fn trace_back( &self, initial_state_index: StateIndex, initial_symbols: &[Symbol], ) -> Vec { let mut stack = vec![(initial_state_index, initial_symbols)]; let mut result = vec![]; while let Some((state_index, symbols)) = stack.pop() { if let Some((head, tail)) = symbols.split_last() { stack.extend( self.graph .edges_directed(NodeIndex::new(state_index.0), EdgeDirection::Incoming) .filter(|edge| edge.weight() == head) .map(|edge| (StateIndex(edge.source().index()), tail)), ); } else { result.push(state_index); } } result.sort(); result.dedup(); result } pub fn successors(&self, state_index: StateIndex) -> Vec { self.graph .edges_directed(NodeIndex::new(state_index.0), EdgeDirection::Outgoing) .map(|edge| StateIndex(edge.target().index())) .collect() } pub fn predecessors(&self, state_index: StateIndex, symbol: Symbol) -> Vec { self.graph .edges_directed(NodeIndex::new(state_index.0), EdgeDirection::Incoming) .filter(|edge| *edge.weight() == symbol) .map(|edge| StateIndex(edge.source().index())) .collect() } } lalrpop-0.17.2/src/lr1/tls.rs000064400000000000000000000016311346406170700141060ustar0000000000000000//! Thread-local data specific to LR(1) processing. use grammar::repr::TerminalSet; use std::cell::RefCell; use std::mem; use std::sync::Arc; thread_local! { static TERMINALS: RefCell>> = RefCell::new(None) } pub struct Lr1Tls { old_value: Option>, } impl Lr1Tls { pub fn install(terminals: TerminalSet) -> Lr1Tls { let old_value = TERMINALS.with(|s| { let mut s = s.borrow_mut(); mem::replace(&mut *s, Some(Arc::new(terminals))) }); Lr1Tls { old_value } } pub fn with(op: OP) -> RET where OP: FnOnce(&TerminalSet) -> RET, { TERMINALS.with(|s| op(s.borrow().as_ref().expect("LR1 TLS not installed"))) } } impl Drop for Lr1Tls { fn drop(&mut self) { TERMINALS.with(|s| *s.borrow_mut() = self.old_value.take()); } } lalrpop-0.17.2/src/lr1/trace/mod.rs000064400000000000000000000015111346406170700151560ustar0000000000000000use collections::{set, Set}; use grammar::repr::*; use lr1::core::*; use lr1::first::FirstSets; use lr1::state_graph::StateGraph; mod reduce; mod shift; mod trace_graph; pub struct Tracer<'trace, 'grammar: 'trace> { states: &'trace [LR1State<'grammar>], first_sets: &'trace FirstSets, state_graph: StateGraph, trace_graph: TraceGraph<'grammar>, visited_set: Set<(StateIndex, NonterminalString)>, } impl<'trace, 'grammar> Tracer<'trace, 'grammar> { pub fn new(first_sets: &'trace FirstSets, states: &'trace [LR1State<'grammar>]) -> Self { Tracer { states, first_sets, state_graph: StateGraph::new(states), trace_graph: TraceGraph::new(), visited_set: set(), } } } pub use self::trace_graph::TraceGraph; lalrpop-0.17.2/src/lr1/trace/reduce/mod.rs000064400000000000000000000074431341573331700164360ustar0000000000000000use grammar::repr::*; use lr1::core::*; use super::trace_graph::*; use super::Tracer; #[cfg(test)] mod test; impl<'trace, 'grammar> Tracer<'trace, 'grammar> { pub fn backtrace_reduce( mut self, item_state: StateIndex, item: LR0Item<'grammar>, ) -> TraceGraph<'grammar> { self.trace_reduce_item(item_state, item); self.trace_graph } fn trace_reduce_item(&mut self, item_state: StateIndex, item: LR0Item<'grammar>) { // We start out with an item // // X = ...p (*) ...s // // which we can (eventually) reduce, though we may have to do // some epsilon reductions first if ...s is non-empty. We want // to trace back until we have (at least) one element of // context for the reduction. let nonterminal = &item.production.nonterminal; // X // Add an edge // // [X] -{...p,_,...s}-> [X = ...p (*) ...s] // // because to reach that item we pushed `...p` from the start // of `X` and afterwards we expect to see `...s`. self.trace_graph .add_edge(nonterminal.clone(), item, item.symbol_sets()); // Walk back to the set of states S where we had: // // X = (*) ...p let pred_states = self.state_graph.trace_back(item_state, item.prefix()); // Add in edges from [X] to all the places [X] can be consumed. for pred_state in pred_states { self.trace_reduce_from_state(pred_state, nonterminal); } } // We know that we can reduce the nonterminal `Y`. We want to find // at least one element of context, so we search back to find out // who will consume that reduced value. So search for those items // that can shift a `Y`: // // Z = ... (*) Y ...s // // If we find that `...s` is potentially empty, then we haven't // actually found any context, and so we may have to keep // searching. fn trace_reduce_from_state(&mut self, item_state: StateIndex, nonterminal: &NonterminalString) // "Y" { if !self.visited_set.insert((item_state, nonterminal.clone())) { return; } for pred_item in self.states[item_state.0] .items .vec .iter() .filter(|i| i.can_shift_nonterminal(nonterminal)) { // Found a state: // // Z = ...p (*) Y ...s // // If `...s` does not match `\epsilon`, then we are done, // because `FIRST(...s)` will provide a token of context. // But otherwise we have to keep searching backwards. let symbol_sets = pred_item.symbol_sets(); let first_suffix = self.first_sets.first0(symbol_sets.suffix); let continue_tracing = first_suffix.contains_eof(); if !continue_tracing { // Add an edge // // [Z = ...p (*) Y ...s] -(...p,Y,...s)-> [Y] // // and stop. self.trace_graph .add_edge(pred_item.to_lr0(), nonterminal.clone(), symbol_sets); } else { // Add an edge // // [Z] -{..p}-> [Y] // // because we can reduce by consuming `...p` // tokens, and continue tracing. self.trace_graph.add_edge( pred_item.production.nonterminal.clone(), nonterminal.clone(), symbol_sets, ); self.trace_reduce_item(item_state, pred_item.to_lr0()); } } } } lalrpop-0.17.2/src/lr1/trace/reduce/test.rs000064400000000000000000000257251346406170700166420ustar0000000000000000use grammar::repr::*; use lr1::build_states; use lr1::core::Item; use lr1::first::FirstSets; use lr1::interpret::interpret_partial; use lr1::lookahead::{Token, TokenSet}; use lr1::tls::Lr1Tls; use string_cache::DefaultAtom as Atom; use test_util::{expect_debug, normalized_grammar}; use tls::Tls; use super::super::Tracer; fn nt(t: &str) -> NonterminalString { NonterminalString(Atom::from(t)) } fn term(t: &str) -> TerminalString { TerminalString::quoted(Atom::from(t)) } macro_rules! terms { ($($t:expr),*) => { vec![$(term($t)),*] } } fn test_grammar1() -> Grammar { normalized_grammar( r#" grammar; pub Start: () = Stmt; pub Stmt: () = { Exprs ";", Exprs }; Exprs: () = { Expr, Exprs "," Expr }; Expr: () = { "Int", Expr "+" "Int", }; "#, ) } #[test] fn backtrace1() { let _tls = Tls::test(); let grammar = test_grammar1(); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let first_sets = FirstSets::new(&grammar); let states = build_states(&grammar, nt("Start")).unwrap(); let tracer = Tracer::new(&first_sets, &states); let state_stack = interpret_partial(&states, terms!["Int"]).unwrap(); let top_state = *state_stack.last().unwrap(); // Top state will have items like: // // Expr = "Int" (*) [EOF], // Expr = "Int" (*) ["+"], // Expr = "Int" (*) [","], // Expr = "Int" (*) [";"] // // Select the ";" one. let semi = Token::Terminal(term(";")); let semi_item = states[top_state.0] .items .vec .iter() .filter(|item| item.lookahead.contains(&semi)) .next() .unwrap(); let backtrace = tracer.backtrace_reduce(top_state, semi_item.to_lr0()); println!("{:#?}", backtrace); let pictures: Vec<_> = backtrace .lr0_examples(semi_item.to_lr0()) .map(|e| e.paint_unstyled()) .collect(); expect_debug( &pictures, r#" [ [ " Exprs "," "Int" ╷ ";"", " │ └─Expr─┤ │", " ├─Exprs──────────┘ │", " └─Stmt───────────────┘" ], [ " Exprs "," "Int" ╷ "," Expr", " │ └─Expr─┤ │", " ├─Exprs──────────┘ │", " └─Exprs───────────────────┘" ], [ " "Int" ╷ ";"", " ├─Expr──┤ │", " ├─Exprs─┘ │", " └─Stmt──────┘" ], [ " "Int" ╷ "," Expr", " ├─Expr──┤ │", " ├─Exprs─┘ │", " └─Exprs──────────┘" ], [ " "Int" ╷ "+" "Int"", " ├─Expr─┘ │", " └─Expr───────────┘" ] ] "# .trim(), ); } #[test] fn backtrace2() { let _tls = Tls::test(); // This grammar yields a S/R conflict. Is it (int -> int) -> int // or int -> (int -> int)? let grammar = normalized_grammar( r#" grammar; pub Ty: () = { "int" => (), "bool" => (), "->" => (), }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let first_sets = FirstSets::new(&grammar); let err = build_states(&grammar, nt("Ty")).unwrap_err(); let tracer = Tracer::new(&first_sets, &err.states); let conflict = err.conflicts[0].clone(); println!("conflict={:?}", conflict); let item = Item { production: conflict.production, index: conflict.production.symbols.len(), lookahead: conflict.lookahead.clone(), }; println!("item={:?}", item); let backtrace = tracer.backtrace_reduce(conflict.state, item.to_lr0()); println!("{:#?}", backtrace); expect_debug( &backtrace, r#" [ (Nonterminal(Ty) -([Ty, "->"], Some(Ty), [])-> Item(Ty = Ty "->" (*) Ty)), (Nonterminal(Ty) -([Ty, "->"], Some(Ty), [])-> Nonterminal(Ty)), (Nonterminal(Ty) -([Ty, "->", Ty], None, [])-> Item(Ty = Ty "->" Ty (*))), (Item(Ty = (*) Ty "->" Ty) -([], Some(Ty), ["->", Ty])-> Nonterminal(Ty)) ] "# .trim(), ); // Check that we can successfully enumerate and paint the examples // here. let pictures: Vec<_> = backtrace .lr1_examples(&first_sets, &item) .map(|e| e.paint_unstyled()) .collect(); expect_debug( &pictures, r#" [ [ " Ty "->" Ty "->" Ty", " ├─Ty─────┘ │", " └─Ty─────────────┘" ] ] "# .trim(), ); } #[test] fn reduce_backtrace_3_graph() { // This grammar yields a S/R conflict. Is it `(int -> int) -> int` // or `int -> (int -> int)`? let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; pub Ty: () = { "int" => (), "bool" => (), "->" => (), }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let first_sets = FirstSets::new(&grammar); let err = build_states(&grammar, nt("Ty")).unwrap_err(); let conflict = err.conflicts[0].clone(); println!("conflict={:?}", conflict); let item = Item { production: conflict.production, index: conflict.production.symbols.len(), lookahead: conflict.lookahead.clone(), }; println!("item={:?}", item); let tracer = Tracer::new(&first_sets, &err.states); let graph = tracer.backtrace_reduce(conflict.state, item.to_lr0()); expect_debug( &graph, r#" [ (Nonterminal(Ty) -([Ty, "->"], Some(Ty), [])-> Item(Ty = Ty "->" (*) Ty)), (Nonterminal(Ty) -([Ty, "->"], Some(Ty), [])-> Nonterminal(Ty)), (Nonterminal(Ty) -([Ty, "->", Ty], None, [])-> Item(Ty = Ty "->" Ty (*))), (Item(Ty = (*) Ty "->" Ty) -([], Some(Ty), ["->", Ty])-> Nonterminal(Ty)) ] "# .trim(), ); let list: Vec<_> = graph .lr1_examples(&first_sets, &item) .map(|example| example.paint_unstyled()) .collect(); expect_debug( &list, r#" [ [ " Ty "->" Ty "->" Ty", " ├─Ty─────┘ │", " └─Ty─────────────┘" ] ] "# .trim(), ); } #[test] fn backtrace_filter() { let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; pub Start: () = Stmt; pub Stmt: () = { Exprs ";" }; Exprs: () = { Expr, Exprs "," Expr }; Expr: () = { ExprAtom ExprSuffix }; ExprSuffix: () = { (), "?", }; ExprAtom: () = { "Int", }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let states = build_states(&grammar, nt("Start")).unwrap(); let first_sets = FirstSets::new(&grammar); let tracer = Tracer::new(&first_sets, &states); let state_stack = interpret_partial(&states, terms!["Int"]).unwrap(); let top_state = *state_stack.last().unwrap(); // Top state will have an item like: // // Expr = "Int" (*) [",", ";"], let semi = Token::Terminal(term(";")); let lr1_item = states[top_state.0] .items .vec .iter() .filter(|item| item.lookahead.contains(&semi)) .next() .unwrap(); let backtrace = tracer.backtrace_reduce(top_state, lr1_item.to_lr0()); println!("{:#?}", backtrace); // With no filtering, we get examples with both `;` and `,` as // lookahead (though `ExprSuffix` is in the way). let pictures: Vec<_> = backtrace .lr0_examples(lr1_item.to_lr0()) .map(|e| e.paint_unstyled()) .collect(); expect_debug( &pictures, r#" [ [ " Exprs "," "Int" ╷ ExprSuffix ";"", " │ ├─ExprAtom─┘ │ │", " │ └─Expr────────────────┤ │", " ├─Exprs─────────────────────────┘ │", " └─Stmt──────────────────────────────┘" ], [ " Exprs "," "Int" ╷ ExprSuffix "," Expr", " │ ├─ExprAtom─┘ │ │", " │ └─Expr────────────────┤ │", " ├─Exprs─────────────────────────┘ │", " └─Exprs──────────────────────────────────┘" ], [ " "Int" ╷ ExprSuffix ";"", " ├─ExprAtom─┘ │ │", " ├─Expr────────────────┤ │", " ├─Exprs───────────────┘ │", " └─Stmt────────────────────┘" ], [ " "Int" ╷ ExprSuffix "," Expr", " ├─ExprAtom─┘ │ │", " ├─Expr────────────────┤ │", " ├─Exprs───────────────┘ │", " └─Exprs────────────────────────┘" ] ] "# .trim(), ); // Select those with `;` as lookahead let semi_item = lr1_item.with_lookahead(TokenSet::from(semi)); let pictures: Vec<_> = backtrace .lr1_examples(&first_sets, &semi_item) .map(|e| e.paint_unstyled()) .collect(); expect_debug( &pictures, r#" [ [ " Exprs "," "Int" ╷ ExprSuffix ";"", " │ ├─ExprAtom─┘ │ │", " │ └─Expr────────────────┤ │", " ├─Exprs─────────────────────────┘ │", " └─Stmt──────────────────────────────┘" ], [ " "Int" ╷ ExprSuffix ";"", " ├─ExprAtom─┘ │ │", " ├─Expr────────────────┤ │", " ├─Exprs───────────────┘ │", " └─Stmt────────────────────┘" ] ] "# .trim(), ); } lalrpop-0.17.2/src/lr1/trace/shift/mod.rs000064400000000000000000000066521341573331700163050ustar0000000000000000use grammar::repr::*; use lr1::core::*; use super::trace_graph::*; use super::Tracer; #[cfg(test)] mod test; /// A backtrace explaining how a particular shift: /// /// X = ...p (*) Token ... /// /// came to be in the list of items for some state S. This backtrace /// always has a particular form. First, we can walk back over the /// prefix, which will bring us to some set of states S1 all of which /// contain the same item, but with the cursor at the front: /// /// X = (*) ...p Token ... /// /// Then we can walk back within those states some number of epsilon /// moves, traversing nonterminals of the form: /// /// Y = (*) X ...s /// /// (Note that each nonterminal `Y` may potentially have many /// productions of this form. I am not sure yet if they all matter or /// not.) /// /// Finally, either we are in the start state, or else we reach some /// production of the form: /// /// Z = ...p (*) Y ...s /// /// Ultimately this "trace" is best represented as a DAG. The problem /// is that some of those nonterminals could, for example, be /// optional. impl<'trace, 'grammar> Tracer<'trace, 'grammar> { pub fn backtrace_shift( mut self, item_state: StateIndex, item: LR0Item<'grammar>, ) -> TraceGraph<'grammar> { let symbol_sets = item.symbol_sets(); // The states `S` let pred_states = self.state_graph.trace_back(item_state, symbol_sets.prefix); // Add the edge `[X] -{...p,Token,...s}-> [X = ...p (*) Token ...s]` self.trace_graph .add_edge(item.production.nonterminal.clone(), item, symbol_sets); for pred_state in pred_states { self.trace_epsilon_edges(pred_state, &item.production.nonterminal); } self.trace_graph } // Because item.index is 0, we know we are at an index // like: // // Y = (*) ... // // This can only arise if `Y` is the start nonterminal // or if there is an epsilon move from another item // like: // // Z = ...p (*) Y ... // // So search for items like Z. fn trace_epsilon_edges(&mut self, item_state: StateIndex, nonterminal: &NonterminalString) // "Y" { if self.visited_set.insert((item_state, nonterminal.clone())) { for pred_item in self.states[item_state.0].items.vec.iter() { if pred_item.can_shift_nonterminal(nonterminal) { if pred_item.index > 0 { // Add an edge: // // [Z = ...p (*) Y ...s] -(...p,Y,...s)-> [Y] self.trace_graph.add_edge( pred_item, nonterminal.clone(), pred_item.symbol_sets(), ); } else { // Trace back any incoming edges to [Z = ...p (*) Y ...]. let pred_nonterminal = &pred_item.production.nonterminal; self.trace_graph.add_edge( pred_nonterminal.clone(), nonterminal.clone(), pred_item.symbol_sets(), ); self.trace_epsilon_edges(item_state, pred_nonterminal); } } } } } } lalrpop-0.17.2/src/lr1/trace/shift/test.rs000064400000000000000000000040661341573331700165020ustar0000000000000000use grammar::repr::*; use lr1::build_states; use lr1::core::*; use lr1::first::FirstSets; use lr1::tls::Lr1Tls; use string_cache::DefaultAtom as Atom; use test_util::{expect_debug, normalized_grammar}; use tls::Tls; use super::super::Tracer; fn nt(t: &str) -> NonterminalString { NonterminalString(Atom::from(t)) } #[test] fn shift_backtrace_1() { // This grammar yields a S/R conflict. Is it `(int -> int) -> int` // or `int -> (int -> int)`? let _tls = Tls::test(); let grammar = normalized_grammar( r#" grammar; pub Ty: () = { "int" => (), "bool" => (), "->" => (), }; "#, ); let _lr1_tls = Lr1Tls::install(grammar.terminals.clone()); let first_sets = FirstSets::new(&grammar); let err = build_states(&grammar, nt("Ty")).unwrap_err(); let conflict = err.conflicts[0].clone(); println!("conflict={:?}", conflict); // Gin up the LR0 item involved in the shift/reduce conflict: // // Ty = Ty (*) -> Ty (shift) // // from the item that we can reduce: // // Ty = Ty -> Ty (*) (reduce) assert!(conflict.production.symbols.len() == 3); let item = Item::lr0(conflict.production, 1); println!("item={:?}", item); let tracer = Tracer::new(&first_sets, &err.states); let graph = tracer.backtrace_shift(conflict.state, item); expect_debug( &graph, r#" [ (Nonterminal(Ty) -([], Some(Ty), ["->", Ty])-> Nonterminal(Ty)), (Nonterminal(Ty) -([Ty], Some("->"), [Ty])-> Item(Ty = Ty (*) "->" Ty)), (Item(Ty = Ty "->" (*) Ty) -([Ty, "->"], Some(Ty), [])-> Nonterminal(Ty)) ] "# .trim(), ); let list: Vec<_> = graph .lr0_examples(item) .map(|example| example.paint_unstyled()) .collect(); expect_debug( &list, r#" [ [ " Ty "->" Ty "->" Ty", " │ └─Ty─────┤", " └─Ty─────────────┘" ] ] "# .trim(), ); } lalrpop-0.17.2/src/lr1/trace/trace_graph/mod.rs000064400000000000000000000365561346406170700174560ustar0000000000000000use collections::{map, Map}; use grammar::repr::*; use lr1::core::*; use lr1::example::*; use lr1::first::*; use lr1::lookahead::*; use petgraph::graph::{EdgeReference, Edges, NodeIndex}; use petgraph::prelude::*; use petgraph::{Directed, EdgeDirection, Graph}; use std::fmt::{Debug, Error, Formatter}; #[cfg(test)] mod test; /// Trace graphs are used to summarize how it is that we came to be in /// a state where we can take some particular shift/reduce action; put /// another way, how it is that we came to be in a state with some /// particular LR(1) item. /// /// The nodes in the graph are each labeled with a TraceGraphNode and /// hence take one of two forms: /// /// - TraceGraphNode::Item -- represents an LR0 item. These nodes are /// used for the starting/end points in the graph only. Basically a /// complete trace stretches from the start item to some end item, /// and all intermediate nodes are nonterminals. /// - TraceGraphNode::Nonterminal -- if this graph is for a shift, /// then these represent items where the cursor is at the beginning: /// `X = (*) ...`. If the graph is for a reduce, they represent /// items where a reduce is possible without shifting any more /// terminals (though further reductions may be needed): `X = /// ... (*) ...s` where `FIRST(...s)` includes `\epsilon`. /// /// The edges in the graph are also important. They are labeled with /// `SymbolSets` instances, meaning that each carries a (prefix, /// cursor, and suffix) tuple. The label on an edge `A -> B` means /// that transitioning from a state containing `A` to a state /// containing `B` is possible if you: /// /// - shift the symbols in `prefix` /// - `B` will produce the symbol in `cursor` /// - shift the symbols in `suffix` after `B` is popped pub struct TraceGraph<'grammar> { // A -L-> B means: // // Transition from a state containing A to a state containing // B by (pushing|popping) the symbols L. // // If this trace graph represents a shift backtrace, then the // labels are symbols that are pushed. Otherwise they are labels // that are popped. graph: Graph, SymbolSets<'grammar>>, indices: Map, NodeIndex>, } #[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)] pub enum TraceGraphNode<'grammar> { Nonterminal(NonterminalString), Item(LR0Item<'grammar>), } impl<'grammar> TraceGraph<'grammar> { pub fn new() -> Self { TraceGraph { graph: Graph::new(), indices: map(), } } pub fn add_node(&mut self, node: T) -> NodeIndex where T: Into>, { let node = node.into(); let graph = &mut self.graph; *self .indices .entry(node.clone()) .or_insert_with(|| graph.add_node(node)) } pub fn add_edge(&mut self, from: F, to: T, labels: SymbolSets<'grammar>) where F: Into>, T: Into>, { let from = self.add_node(from.into()); let to = self.add_node(to.into()); if !self .graph .edges_directed(from, EdgeDirection::Outgoing) .any(|edge| edge.target() == to && *edge.weight() == labels) { self.graph.add_edge(from, to, labels); } } pub fn lr0_examples<'graph>( &'graph self, lr0_item: LR0Item<'grammar>, ) -> PathEnumerator<'graph, 'grammar> { PathEnumerator::new(self, lr0_item) } pub fn lr1_examples<'trace>( &'trace self, first_sets: &'trace FirstSets, item: &LR1Item<'grammar>, ) -> FilteredPathEnumerator<'trace, 'grammar> { FilteredPathEnumerator::new(first_sets, self, item.to_lr0(), item.lookahead.clone()) } } impl<'grammar> Into> for NonterminalString { fn into(self) -> TraceGraphNode<'grammar> { TraceGraphNode::Nonterminal(self) } } impl<'grammar, L: Lookahead> Into> for Item<'grammar, L> { fn into(self) -> TraceGraphNode<'grammar> { (&self).into() } } impl<'a, 'grammar, L: Lookahead> Into> for &'a Item<'grammar, L> { fn into(self) -> TraceGraphNode<'grammar> { TraceGraphNode::Item(self.to_lr0()) } } // This just exists to help with the `Debug` impl struct TraceGraphEdge<'grammar> { from: TraceGraphNode<'grammar>, to: TraceGraphNode<'grammar>, label: ( &'grammar [Symbol], Option<&'grammar Symbol>, &'grammar [Symbol], ), } impl<'grammar> Debug for TraceGraphEdge<'grammar> { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { write!(fmt, "({:?} -{:?}-> {:?})", self.from, self.label, self.to) } } impl<'grammar> Debug for TraceGraph<'grammar> { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { let mut s = fmt.debug_list(); for (node, &index) in &self.indices { for edge in self.graph.edges_directed(index, EdgeDirection::Outgoing) { let label = edge.weight(); s.entry(&TraceGraphEdge { from: node.clone(), to: self.graph[edge.target()].clone(), label: (label.prefix, label.cursor, label.suffix), }); } } s.finish() } } /////////////////////////////////////////////////////////////////////////// // PathEnumerator // // The path enumerater walks a trace graph searching for paths that // start at a given item and terminate at another item. If such a path // is found, you can then find the complete list of symbols by calling // `symbols_and_cursor` and also get access to the state. pub struct PathEnumerator<'graph, 'grammar: 'graph> { graph: &'graph TraceGraph<'grammar>, stack: Vec>, } struct EnumeratorState<'graph, 'grammar: 'graph> { index: NodeIndex, symbol_sets: SymbolSets<'grammar>, edges: Edges<'graph, SymbolSets<'grammar>, Directed>, } impl<'graph, 'grammar> PathEnumerator<'graph, 'grammar> { fn new(graph: &'graph TraceGraph<'grammar>, lr0_item: LR0Item<'grammar>) -> Self { let start_state = graph.indices[&TraceGraphNode::Item(lr0_item)]; let mut enumerator = PathEnumerator { graph, stack: vec![], }; let edges = enumerator.incoming_edges(start_state); enumerator.stack.push(EnumeratorState { index: start_state, symbol_sets: SymbolSets::new(), edges, }); enumerator.find_next_trace(); enumerator } /// Advance to the next example. Returns false if there are no more /// examples. pub fn advance(&mut self) -> bool { // If we have not yet exhausted all the examples, then the top // of the stack should be the last target item that we // found. Pop it off. match self.stack.pop() { Some(top_state) => { assert!(match self.graph.graph[top_state.index] { TraceGraphNode::Item(_) => true, TraceGraphNode::Nonterminal(_) => false, }); self.find_next_trace() } None => false, } } fn incoming_edges(&self, index: NodeIndex) -> Edges<'graph, SymbolSets<'grammar>, Directed> { self.graph .graph .edges_directed(index, EdgeDirection::Incoming) } /// This is the main operation, written in CPS style and hence it /// can seem a bit confusing. The idea is that `find_next_trace` /// is called when we are ready to consider the next child of /// whatever is on the top of the stack. It simply withdraws /// that next child (if any) and hands it to `push_next`. fn find_next_trace(&mut self) -> bool { if !self.stack.is_empty() { let next_edge = { let top_of_stack = self.stack.last_mut().unwrap(); top_of_stack.edges.next() }; self.push_next_child_if_any(next_edge) } else { false } } /// Invoked with the next child (if any) of the node on the top of /// the stack. /// /// If `next` is `Some`, we simply call `push_next_child`. /// /// If `next` is `None`, then the node on the top of /// the stack *has* no next child, and so it is popped, and then /// we call `find_next_trace` again to start with the next child /// of the new top of the stack. fn push_next_child_if_any( &mut self, next: Option>>, ) -> bool { if let Some(edge) = next { let index = edge.source(); let symbol_sets = *edge.weight(); self.push_next_child(index, symbol_sets) } else { self.stack.pop(); self.find_next_trace() } } /// Push the next child of the top of the stack onto the stack, /// making the child the new top. /// /// If the child is an `Item` node, we have found the next trace, /// and hence our search terminates. We push the symbols from this /// item node into the symbols vector and then return true. /// /// Otherwise, we check whether this new node would cause a cycle. /// If so, we do *not* push it, and instead just call /// `find_next_trace` again to proceed to the next child of the /// current top. /// /// Finally, if the new node would NOT cause a cycle, then we can /// push it onto the stack so that it becomes the new top, and /// call `find_next_trace` to start searching its children. fn push_next_child(&mut self, index: NodeIndex, symbol_sets: SymbolSets<'grammar>) -> bool { match self.graph.graph[index] { TraceGraphNode::Item(_) => { // If we reached an item like // // X = ...p (*) ...s // // then we are done, but we still need to push on the // symbols `...p`. let edges = self.incoming_edges(index); self.stack.push(EnumeratorState { index, symbol_sets, edges, }); true } TraceGraphNode::Nonterminal(_) => { // If this node already appears on the stack, do not // visit its children. if !self.stack.iter().any(|state| state.index == index) { let edges = self.incoming_edges(index); self.stack.push(EnumeratorState { index, symbol_sets, edges, }); } self.find_next_trace() } } } pub fn found_trace(&self) -> bool { !self.stack.is_empty() } /// Returns the 1-context for the current trace. In other words, /// the set of tokens that may appear next in the input. If this /// trace was derived from a shiftable item, this will always be /// the terminal that was to be shifted; if derived from a reduce /// item, this constitutes the set of lookaheads that will trigger /// a reduce. pub fn first0(&self, first_sets: &FirstSets) -> TokenSet { assert!(self.found_trace()); first_sets.first0( self.stack[1] .symbol_sets .cursor .into_iter() .chain(self.stack.iter().flat_map(|s| s.symbol_sets.suffix)), ) } pub fn example(&self) -> Example { assert!(self.found_trace()); let mut symbols = vec![]; symbols.extend( self.stack .iter() .rev() .flat_map(|s| s.symbol_sets.prefix) .cloned() .map(ExampleSymbol::Symbol), ); let cursor = symbols.len(); match self.stack[1].symbol_sets.cursor { Some(s) => symbols.push(ExampleSymbol::Symbol(s.clone())), None => { if self.stack[1].symbol_sets.prefix.is_empty() { symbols.push(ExampleSymbol::Epsilon) } else { } } } symbols.extend( self.stack .iter() .flat_map(|s| s.symbol_sets.suffix) .cloned() .map(ExampleSymbol::Symbol), ); let mut cursors = (0, symbols.len()); let mut reductions: Vec<_> = self.stack[1..] .iter() .rev() .map(|state| { let nonterminal = match self.graph.graph[state.index] { TraceGraphNode::Nonterminal(ref nonterminal) => nonterminal.clone(), TraceGraphNode::Item(ref item) => item.production.nonterminal.clone(), }; let reduction = Reduction { start: cursors.0, end: cursors.1, nonterminal, }; cursors.0 += state.symbol_sets.prefix.len(); cursors.1 -= state.symbol_sets.suffix.len(); reduction }) .collect(); reductions.reverse(); Example { symbols, cursor, reductions, } } } impl<'graph, 'grammar> Iterator for PathEnumerator<'graph, 'grammar> { type Item = Example; fn next(&mut self) -> Option { if self.found_trace() { let example = self.example(); self.advance(); Some(example) } else { None } } } /////////////////////////////////////////////////////////////////////////// // FilteredPathEnumerator // // Like the path enumerator, but tests for examples with some specific // lookahead pub struct FilteredPathEnumerator<'graph, 'grammar: 'graph> { base: PathEnumerator<'graph, 'grammar>, first_sets: &'graph FirstSets, lookahead: TokenSet, } impl<'graph, 'grammar> FilteredPathEnumerator<'graph, 'grammar> { fn new( first_sets: &'graph FirstSets, graph: &'graph TraceGraph<'grammar>, lr0_item: LR0Item<'grammar>, lookahead: TokenSet, ) -> Self { FilteredPathEnumerator { base: PathEnumerator::new(graph, lr0_item), first_sets, lookahead, } } } impl<'graph, 'grammar> Iterator for FilteredPathEnumerator<'graph, 'grammar> { type Item = Example; fn next(&mut self) -> Option { while self.base.found_trace() { let firsts = self.base.first0(self.first_sets); if firsts.is_intersecting(&self.lookahead) { let example = self.base.example(); self.base.advance(); return Some(example); } self.base.advance(); } None } } lalrpop-0.17.2/src/lr1/trace/trace_graph/test.rs000064400000000000000000000075431341573331700176470ustar0000000000000000use grammar::repr::*; use lr1::core::*; use string_cache::DefaultAtom as Atom; use test_util::expect_debug; use tls::Tls; macro_rules! nt { ($x:ident) => { NonterminalString(Atom::from(stringify!($x))) }; } macro_rules! syms { ($($x:ident),*) => { vec![$(Symbol::Nonterminal(nt!($x))),*] } } macro_rules! production { ($x:ident = $($y:ident)*) => { Production { nonterminal: nt!($x), symbols: syms![$($y),*], action: ActionFn::new(0), span: Span(0, 0) } } } use super::TraceGraph; #[test] fn enumerator() { let _tls = Tls::test(); // Build this graph: // // X = X0 (*) X1 // ^ // | // {X0} // | // +-> X <-- Z = Z0 (*) X Z1 // | // Y = Y0 (*) X Y1 // // which enumerates out to: // // [Y0 X0 (*) X1 Y1] // [Z0 X0 (*) X1 Z1] let productions = vec![ production![X = X0 X1], production![Y = Y0 X Y1], production![Z = Z0 X Z1], ]; let mut graph = TraceGraph::new(); let item0 = Item::lr0(&productions[0], 1); // X = X0 (*) X1 graph.add_edge(nt!(X), item0, item0.symbol_sets()); let item1 = Item::lr0(&productions[1], 1); // Y = Y0 (*) X Y1 graph.add_edge(item1, nt!(X), item1.symbol_sets()); let item2 = Item::lr0(&productions[2], 1); // Z = Z0 (*) X Z1 graph.add_edge(item2, nt!(X), item2.symbol_sets()); let enumerator = graph.lr0_examples(Item::lr0(&productions[0], 1)); let list: Vec<_> = enumerator.map(|example| example.paint_unstyled()).collect(); expect_debug( &list, r#" [ [ " Z0 X0 X1 Z1", " │ └─X─┘ │", " └─Z───────┘" ], [ " Y0 X0 X1 Y1", " │ └─X─┘ │", " └─Y───────┘" ] ] "# .trim(), ); } #[test] fn enumerator1() { let _tls = Tls::test(); // Build this graph: // // W = W0 W1 (*) // ^ // {W0,W1} // | // W // ^ // {X0} // | // +-> X <-- Z = Z0 (*) X Z1 // | // Y = Y0 (*) X Y1 // // which enumerates out to: // // [Y0 X0 (*) X1 Y1] // [Z0 X0 (*) X1 Z1] let productions = vec![ production![W = W0 W1], production![X = X0 W X1], // where X1 may be empty production![Y = Y0 X Y1], production![Z = Z0 X Z1], ]; let mut graph = TraceGraph::new(); let item0 = Item::lr0(&productions[0], 2); // W = W0 W1 (*) graph.add_edge(nt!(W), item0, item0.symbol_sets()); graph.add_edge( nt!(X), nt!(W), SymbolSets { prefix: &productions[1].symbols[..1], cursor: Some(&productions[1].symbols[1]), suffix: &productions[1].symbols[2..], }, ); let item1 = Item::lr0(&productions[2], 1); graph.add_edge(item1, nt!(X), item1.symbol_sets()); let item2 = Item::lr0(&productions[3], 1); graph.add_edge(item2, nt!(X), item2.symbol_sets()); let enumerator = graph.lr0_examples(Item::lr0(&productions[0], 2)); let list: Vec<_> = enumerator.map(|example| example.paint_unstyled()).collect(); expect_debug( &list, r#" [ [ " Z0 X0 W0 W1 X1 Z1", " │ │ └─W─┘ │ │", " │ └─X───────┘ │", " └─Z─────────────┘" ], [ " Y0 X0 W0 W1 X1 Y1", " │ │ └─W─┘ │ │", " │ └─X───────┘ │", " └─Y─────────────┘" ] ] "# .trim(), ); } lalrpop-0.17.2/src/main.rs000064400000000000000000000126101346406170700135310ustar0000000000000000extern crate docopt; extern crate lalrpop; #[macro_use] extern crate serde_derive; extern crate serde; use docopt::Docopt; use lalrpop::Configuration; use std::env; use std::io::{self, Write}; use std::path::PathBuf; use std::process; static VERSION: &'static str = env!("CARGO_PKG_VERSION"); fn main() { main1().unwrap(); } fn main1() -> io::Result<()> { let mut stderr = std::io::stderr(); let mut stdout = std::io::stdout(); let args: Args = Docopt::new(USAGE) .and_then(|d| d.argv(env::args()).deserialize()) .unwrap_or_else(|e| e.exit()); if args.flag_version { writeln!(stdout, "{}", VERSION)?; process::exit(0); } let mut config = Configuration::new(); match args.flag_level.unwrap_or(LevelFlag::Info) { LevelFlag::Quiet => config.log_quiet(), LevelFlag::Info => config.log_info(), LevelFlag::Verbose => config.log_verbose(), LevelFlag::Debug => config.log_debug(), }; if args.flag_force { config.force_build(true); } if args.flag_color { config.always_use_colors(); } if args.flag_comments { config.emit_comments(true); } if args.flag_no_whitespace { config.emit_whitespace(false); } if args.flag_report { config.emit_report(true); } if args.arg_inputs.is_empty() { writeln!( stderr, "Error: no input files specified! Try --help for help." )?; process::exit(1); } if let Some(ref out_dir) = args.flag_out_dir { config.set_out_dir(out_dir); } if let Some(ref flag_features) = args.flag_features { config.set_features(flag_features.split(',').map(String::from)); } for arg in args.arg_inputs { match config.process_file(&arg) { Ok(()) => {} Err(err) => { writeln!(stderr, "Error encountered processing `{}`: {}", arg, err)?; process::exit(1); } } } Ok(()) } const USAGE: &str = " Usage: lalrpop [options] ... lalrpop --help lalrpop (-V | --version) Options: -V, --version Print version. -l, --level LEVEL Set the debug level. (Default: info) Valid values: quiet, info, verbose, debug. -o, --out-dir DIR Sets the directory in which to output the .rs file(s). --features FEATURES Comma separated list of features for conditional compilation. -f, --force Force execution, even if the .lalrpop file is older than the .rs file. -c, --color Force colorful output, even if this is not a TTY. --no-whitespace Removes redundant whitespace from the generated file. (Default: false) --comments Enable comments in the generated code. --report Generate report files. "; #[derive(Debug, Deserialize)] struct Args { arg_inputs: Vec, flag_out_dir: Option, flag_features: Option, flag_level: Option, flag_force: bool, flag_color: bool, flag_comments: bool, flag_no_whitespace: bool, flag_report: bool, flag_version: bool, } #[derive(Debug, Deserialize)] enum LevelFlag { Quiet, Info, Verbose, Debug, } #[cfg(test)] mod test { use super::Args; use super::USAGE; use docopt::Docopt; #[test] fn test_usage_help() { let argv = || vec!["lalrpop", "--help"]; let _: Args = Docopt::new(USAGE) .and_then(|d| d.help(false).argv(argv().into_iter()).deserialize()) .unwrap(); } #[test] fn test_usage_version() { let argv = || vec!["lalrpop", "--version"]; let _: Args = Docopt::new(USAGE) .and_then(|d| d.argv(argv().into_iter()).deserialize()) .unwrap(); } #[test] fn test_usage_single_input() { let argv = || vec!["lalrpop", "file.lalrpop"]; let _: Args = Docopt::new(USAGE) .and_then(|d| d.argv(argv().into_iter()).deserialize()) .unwrap(); } #[test] fn test_usage_multiple_inputs() { let argv = || vec!["lalrpop", "file.lalrpop", "../file2.lalrpop"]; let _: Args = Docopt::new(USAGE) .and_then(|d| d.argv(argv().into_iter()).deserialize()) .unwrap(); } #[test] fn out_dir() { let argv = || vec!["lalrpop", "--out-dir", "abc", "file.lalrpop"]; let args: Args = Docopt::new(USAGE) .and_then(|d| d.argv(argv().into_iter()).deserialize()) .unwrap(); assert_eq!(args.flag_out_dir, Some("abc".into())); } #[test] fn features() { let argv = || vec!["lalrpop", "--features", "test,abc", "file.lalrpop"]; let args: Args = Docopt::new(USAGE) .and_then(|d| d.argv(argv().into_iter()).deserialize()) .unwrap(); assert_eq!(args.flag_features, Some("test,abc".to_string())); } #[test] fn emit_whitespace() { let argv = || vec!["lalrpop", "--no-whitespace", "file.lalrpop"]; let args: Args = Docopt::new(USAGE) .and_then(|d| d.argv(argv().into_iter()).deserialize()) .unwrap(); assert!(args.flag_no_whitespace, true); } } lalrpop-0.17.2/src/message/builder.rs000064400000000000000000000213431350346013400156510ustar0000000000000000use grammar::parse_tree::Span; use message::horiz::Horiz; use message::indent::Indent; use message::styled::Styled; use message::text::Text; use message::vert::Vert; use message::wrap::Wrap; use message::{Content, Message}; use style::Style; pub struct MessageBuilder { span: Span, heading: Option>, body: Option>, } pub struct HeadingCharacter { message: MessageBuilder, } pub struct BodyCharacter { message: MessageBuilder, } impl MessageBuilder { pub fn new(span: Span) -> Self { MessageBuilder { span, heading: None, body: None, } } pub fn heading(self) -> Builder { Builder::new(HeadingCharacter { message: self }) } pub fn body(self) -> Builder { Builder::new(BodyCharacter { message: self }) } pub fn end(self) -> Message { Message::new( self.span, self.heading.expect("never defined a heading"), self.body.expect("never defined a body"), ) } } impl Character for HeadingCharacter { type End = MessageBuilder; fn end(mut self, items: Vec>) -> MessageBuilder { assert!( self.message.heading.is_none(), "already defined a heading for this message" ); self.message.heading = Some(Box::new(Vert::new(items, 1))); self.message } } impl Character for BodyCharacter { type End = MessageBuilder; fn end(mut self, items: Vec>) -> MessageBuilder { assert!( self.message.body.is_none(), "already defined a body for this message" ); self.message.body = Some(Box::new(Vert::new(items, 2))); self.message } } /////////////////////////////////////////////////////////////////////////// // Inline builder: Useful for constructing little bits of content: for // example, converting an Example into something renderable. Using an // inline builder, if you push exactly one item, then when you call // `end` that is what you get; otherwise, you get items laid out // adjacent to one another horizontally (no spaces in between). pub struct InlineBuilder; impl InlineBuilder { pub fn new() -> Builder { Builder::new(InlineBuilder) } } impl Character for InlineBuilder { type End = Box; fn end(self, mut items: Vec>) -> Box { if items.len() == 1 { items.pop().unwrap() } else { Box::new(Horiz::new(items, 1)) } } } /////////////////////////////////////////////////////////////////////////// // Builder -- generic helper for multi-part items /// The builder is used to construct multi-part items. It is intended /// to be used in a "method-call chain" style. The base method is /// called `push`, and it simply pushes a new child of the current /// parent. /// /// Methods whose name like `begin_foo` are used to create a new /// multi-part child; they return a fresh builder corresponding to the /// child. When the child is completely constructed, call `end` to /// finish the child builder and return to the parent builder. /// /// Methods whose name ends in "-ed", such as `styled`, post-process /// the last item pushed. They will panic if invoked before any items /// have been pushed. /// /// Example: /// /// ``` /// let node = InlineBuilder::new() /// .begin_lines() // starts a child builder for adjacent lines /// .text("foo") // add a text node "foo" to the child builder /// .text("bar") // add a text node "bar" to the child builder /// .end() // finish the lines builder, return to the parent /// .end(); // finish the parent `InlineBuilder`, yielding up the /// // `lines` child that was pushed (see `InlineBuilder` /// // for more details) /// ``` pub struct Builder { items: Vec>, character: C, } impl Builder { fn new(character: C) -> Self { Builder { items: vec![], character, } } pub fn push(mut self, item: I) -> Self where I: Into>, { self.items.push(item.into()); self } fn pop(&mut self) -> Option> { self.items.pop() } pub fn begin_vert(self, separate: usize) -> Builder> { Builder::new(VertCharacter { base: self, separate, }) } pub fn begin_lines(self) -> Builder> { self.begin_vert(1) } pub fn begin_paragraphs(self) -> Builder> { self.begin_vert(2) } pub fn begin_horiz(self, separate: usize) -> Builder> { Builder::new(HorizCharacter { base: self, separate, }) } // "item1item2" pub fn begin_adjacent(self) -> Builder> { self.begin_horiz(1) } // "item1 item2" pub fn begin_spaced(self) -> Builder> { self.begin_horiz(2) } pub fn begin_wrap(self) -> Builder> { Builder::new(WrapCharacter { base: self }) } pub fn styled(mut self, style: Style) -> Self { let content = self.pop().expect("bold must be applied to an item"); self.push(Box::new(Styled::new(style, content))) } pub fn indented_by(mut self, amount: usize) -> Self { let content = self.pop().expect("indent must be applied to an item"); self.push(Box::new(Indent::new(amount, content))) } pub fn indented(self) -> Self { self.indented_by(2) } pub fn text(self, text: T) -> Self { self.push(Box::new(Text::new(text.to_string()))) } /// Take the item just pushed and makes some text adjacent to it. /// E.g. `builder.wrap().text("foo").adjacent_text(".").end()` /// result in `"foo."` being printed without any wrapping in /// between. pub fn adjacent_text(mut self, prefix: T, suffix: U) -> Self { let item = self.pop().expect("adjacent text must be added to an item"); let prefix = prefix.to_string(); let suffix = suffix.to_string(); if !prefix.is_empty() && !suffix.is_empty() { self.begin_adjacent() .text(prefix) .push(item) .text(suffix) .end() } else if !suffix.is_empty() { self.begin_adjacent().push(item).text(suffix).end() } else if !prefix.is_empty() { self.begin_adjacent().text(prefix).push(item).end() } else { self.push(item) } } pub fn verbatimed(self) -> Self { self.adjacent_text("`", "`") } pub fn punctuated(self, text: T) -> Self { self.adjacent_text("", text) } pub fn wrap_text(self, text: T) -> Self { self.begin_wrap().text(text).end() } pub fn end(self) -> C::End { self.character.end(self.items) } } pub trait Character { type End; fn end(self, items: Vec>) -> Self::End; } /////////////////////////////////////////////////////////////////////////// pub struct HorizCharacter { base: Builder, separate: usize, } impl Character for HorizCharacter { type End = Builder; fn end(self, items: Vec>) -> Builder { self.base.push(Box::new(Horiz::new(items, self.separate))) } } /////////////////////////////////////////////////////////////////////////// pub struct VertCharacter { base: Builder, separate: usize, } impl Character for VertCharacter { type End = Builder; fn end(self, items: Vec>) -> Builder { self.base.push(Box::new(Vert::new(items, self.separate))) } } /////////////////////////////////////////////////////////////////////////// pub struct WrapCharacter { base: Builder, } impl Character for WrapCharacter { type End = Builder; fn end(self, items: Vec>) -> Builder { self.base.push(Box::new(Wrap::new(items))) } } impl From> for Box where T: Content + 'static, { fn from(b: Box) -> Box { b } } lalrpop-0.17.2/src/message/horiz.rs000064400000000000000000000020641350346013400153550ustar0000000000000000use super::*; use ascii_canvas::AsciiView; use itertools::Itertools; #[derive(Debug)] pub struct Horiz { items: Vec>, separate: usize, // 0 => overlapping, 1 => each on its own line, 2 => paragraphs } impl Horiz { pub fn new(items: Vec>, separate: usize) -> Self { Horiz { items, separate } } } impl Content for Horiz { fn min_width(&self) -> usize { self.items .iter() .map(|c| c.min_width()) .intersperse(self.separate) .sum() } fn emit(&self, view: &mut dyn AsciiView) { emit_horiz(view, &self.items, self.separate); } fn into_wrap_items(self: Box, wrap_items: &mut Vec>) { wrap_items.push(self); } } pub fn emit_horiz(view: &mut dyn AsciiView, items: &[Box], separate: usize) { let mut column = 0; for item in items { let (_, end_column) = item.emit_at(view, 0, column); column = end_column + separate; } } lalrpop-0.17.2/src/message/indent.rs000064400000000000000000000012411350346013400154770ustar0000000000000000use super::*; use ascii_canvas::AsciiView; #[derive(Debug)] pub struct Indent { amount: usize, content: Box, } impl Indent { pub fn new(amount: usize, content: Box) -> Self { Indent { amount, content } } } impl Content for Indent { fn min_width(&self) -> usize { self.content.min_width() + self.amount } fn emit(&self, view: &mut dyn AsciiView) { let mut subview = view.shift(0, self.amount); self.content.emit(&mut subview); } fn into_wrap_items(self: Box, wrap_items: &mut Vec>) { wrap_items.push(self); } } lalrpop-0.17.2/src/message/message.rs000064400000000000000000000041501350346013400156440ustar0000000000000000use ascii_canvas::AsciiView; use grammar::parse_tree::Span; use message::Content; use std::cmp; use std::fmt::{Debug, Error, Formatter}; use style::Style; use tls::Tls; /// The top-level message display like this: /// /// ``` /// : /// /// /// ``` /// /// This is equivalent to a /// /// ``` /// Vert[separate=2] { /// Horiz[separate=1] { /// Horiz[separate=0] { /// Citation { span }, /// Text { ":" }, /// }, /// , /// }, /// /// } /// ``` pub struct Message { span: Span, heading: Box, body: Box, } impl Message { pub fn new(span: Span, heading: Box, body: Box) -> Self { Message { span, heading, body, } } } impl Content for Message { fn min_width(&self) -> usize { let file_text = Tls::file_text(); let span = file_text.span_str(self.span).chars().count(); let heading = self.heading.min_width(); let body = self.body.min_width(); cmp::max(span + heading + 2, body + 2) } fn emit(&self, view: &mut dyn AsciiView) { let session = Tls::session(); let file_text = Tls::file_text(); let span = file_text.span_str(self.span); view.write_chars(0, 0, span.chars(), Style::new()); let count = span.chars().count(); view.write_chars(0, count, ":".chars(), Style::new()); let (row, _) = self .heading .emit_at(&mut view.styled(session.heading), 0, count + 2); self.body.emit_at(view, row + 2, 2); } fn into_wrap_items(self: Box, wrap_items: &mut Vec>) { wrap_items.push(self); } } impl Debug for Message { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { fmt.debug_struct("Message") .field("span", &self.span) .field("heading", &self.heading) .field("body", &self.body) .finish() } } lalrpop-0.17.2/src/message/mod.rs000064400000000000000000000047551352730432300150150ustar0000000000000000use ascii_canvas::{AsciiCanvas, AsciiView}; use std::cmp; use std::fmt::Debug; pub mod builder; pub mod horiz; pub mod indent; pub mod message; pub mod styled; #[cfg(test)] mod test; pub mod text; pub mod vert; pub mod wrap; /// Content which can be rendered. pub trait Content: Debug { fn min_width(&self) -> usize; fn emit(&self, view: &mut dyn AsciiView); /// Creates a canvas at least `min_width` in width (it may be /// larger if the content requires that) and fills it with the /// current content. Returns the canvas. Typically `min_width` /// would be 80 or the width of the current terminal. fn emit_to_canvas(&self, min_width: usize) -> AsciiCanvas { let computed_min = self.min_width(); let min_width = cmp::max(min_width, computed_min); debug!( "emit_to_canvas: min_width={} computed_min={} self={:#?}", min_width, computed_min, self ); let mut canvas = AsciiCanvas::new(0, min_width); self.emit(&mut canvas); canvas } /// Emit at a particular upper-left corner, returning the /// lower-right corner that was emitted. fn emit_at(&self, view: &mut dyn AsciiView, row: usize, column: usize) -> (usize, usize) { debug!( "emit_at({},{}) self={:?} min_width={:?}", row, column, self, self.min_width() ); let mut shifted_view = view.shift(row, column); self.emit(&mut shifted_view); let (r, c) = shifted_view.close(); (r, c) } /// When items are enclosed into a wrap, this method deconstructs /// them into their indivisible components. fn into_wrap_items(self: Box, wrap_items: &mut Vec>); } /// Helper function: convert `content` into wrap items and then map /// those with `op`, appending the final result into `wrap_items`. /// Useful for "modifier" content items like `Styled` that do not /// affect wrapping. fn into_wrap_items_map( content: Box, wrap_items: &mut Vec>, op: OP, ) where OP: FnMut(Box) -> C, C: Content + 'static, { let mut subvector = vec![]; content.into_wrap_items(&mut subvector); wrap_items.extend( subvector .into_iter() .map(op) .map(|item| Box::new(item) as Box), ); } pub use self::message::Message; lalrpop-0.17.2/src/message/styled.rs000064400000000000000000000017001350346013400155220ustar0000000000000000use super::*; use ascii_canvas::AsciiView; use std::fmt::{Debug, Error, Formatter}; use style::Style; pub struct Styled { style: Style, content: Box, } impl Styled { pub fn new(style: Style, content: Box) -> Self { Styled { style, content } } } impl Content for Styled { fn min_width(&self) -> usize { self.content.min_width() } fn emit(&self, view: &mut dyn AsciiView) { self.content.emit(&mut view.styled(self.style)) } fn into_wrap_items(self: Box, wrap_items: &mut Vec>) { let style = self.style; super::into_wrap_items_map(self.content, wrap_items, |item| Styled::new(style, item)) } } impl Debug for Styled { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { fmt.debug_struct("Styled") .field("content", &self.content) .finish() } } lalrpop-0.17.2/src/message/test.rs000064400000000000000000000076451341573331700152230ustar0000000000000000use ascii_canvas::AsciiCanvas; use grammar::parse_tree::Span; use message::builder::MessageBuilder; use test_util::expect_debug; use tls::Tls; use super::*; fn install_tls() -> Tls { Tls::test_string( r#"foo bar baz "#, ) } #[test] fn hello_world() { let _tls = install_tls(); let msg = MessageBuilder::new(Span(0, 2)) .heading() .text("Hello, world!") .end() .body() .begin_wrap() .text( "This is a very, very, very, very long sentence. \ OK, not THAT long!", ) .end() .indented_by(4) .end() .end(); let min_width = msg.min_width(); let mut canvas = AsciiCanvas::new(0, min_width); msg.emit(&mut canvas); expect_debug( &canvas.to_strings(), r#" [ "tmp.txt:1:1: 1:2: Hello, world!", "", " This is a very, very,", " very, very long sentence.", " OK, not THAT long!" ] "# .trim(), ); } /// Test a case where the body in the message is longer than the /// header (which used to mess up the `min_width` computation). #[test] fn long_body() { let _tls = install_tls(); let msg = MessageBuilder::new(Span(0, 2)) .heading() .text("Hello, world!") .end() .body() .text( "This is a very, very, very, very long sentence. \ OK, not THAT long!", ) .end() .end(); let min_width = msg.min_width(); let mut canvas = AsciiCanvas::new(0, min_width); msg.emit(&mut canvas); expect_debug( &canvas.to_strings(), r#" [ "tmp.txt:1:1: 1:2: Hello, world!", "", " This is a very, very, very, very long sentence. OK, not THAT long!" ] "# .trim(), ); } #[test] fn paragraphs() { let _tls = install_tls(); let msg = MessageBuilder::new(Span(0, 2)) .heading() .text("Hello, world!") .end() // heading .body() .begin_paragraphs() .begin_wrap() .text( "This is the first paragraph. It contains a lot of really interesting \ information that the reader will no doubt peruse with care.", ) .end() .begin_wrap() .text( "This is the second paragraph. It contains even more really interesting \ information that the reader will no doubt skip over with wild abandon.", ) .end() .begin_wrap() .text( "This is the final paragraph. The reader won't even spare this one \ a second glance, despite it containing just waht they need to know \ to solve their problem and to derive greater pleasure from life. \ The secret: All you need is love! Dum da da dum.", ) .end() .end() .end() .end(); let min_width = msg.min_width(); let mut canvas = AsciiCanvas::new(0, min_width); msg.emit(&mut canvas); expect_debug( &canvas.to_strings(), r#" [ "tmp.txt:1:1: 1:2: Hello, world!", "", " This is the first paragraph.", " It contains a lot of really", " interesting information that", " the reader will no doubt", " peruse with care.", "", " This is the second paragraph.", " It contains even more really", " interesting information that", " the reader will no doubt skip", " over with wild abandon.", "", " This is the final paragraph.", " The reader won't even spare", " this one a second glance,", " despite it containing just", " waht they need to know to", " solve their problem and to", " derive greater pleasure from", " life. The secret: All you", " need is love! Dum da da dum." ] "# .trim(), ); } lalrpop-0.17.2/src/message/text.rs000064400000000000000000000016631350346013400152120ustar0000000000000000use ascii_canvas::AsciiView; use style::Style; use super::*; /// Text to be display. This will be flowed appropriately depending on /// the container; e.g., in a Horiz, it will be one unit, but in a /// Wrap, it will be broken up word by word. #[derive(Debug)] pub struct Text { text: String, } impl Text { pub fn new(text: String) -> Self { Text { text } } } impl Content for Text { fn min_width(&self) -> usize { self.text.chars().count() } fn emit(&self, view: &mut dyn AsciiView) { view.write_chars(0, 0, self.text.chars(), Style::new()) } fn into_wrap_items(self: Box, wrap_items: &mut Vec>) { wrap_items.extend( self.text .split_whitespace() .map(|word| Text::new(word.to_string())) .map(|item| Box::new(item) as Box), ); } } lalrpop-0.17.2/src/message/vert.rs000064400000000000000000000016721350346013400152060ustar0000000000000000use super::*; use ascii_canvas::AsciiView; #[derive(Debug)] pub struct Vert { items: Vec>, separate: usize, // 0 => overlapping, 1 => each on its own line, 2 => paragraphs } impl Vert { pub fn new(items: Vec>, separate: usize) -> Self { Vert { items, separate } } } impl Content for Vert { fn min_width(&self) -> usize { self.items.iter().map(|c| c.min_width()).max().unwrap() } fn emit(&self, view: &mut dyn AsciiView) { emit_vert(view, &self.items, self.separate); } fn into_wrap_items(self: Box, wrap_items: &mut Vec>) { wrap_items.push(self); } } pub fn emit_vert(view: &mut dyn AsciiView, items: &[Box], separate: usize) { let mut row = 0; for item in items { let (end_row, _) = item.emit_at(view, row, 0); row = end_row + separate; } } lalrpop-0.17.2/src/message/wrap.rs000064400000000000000000000030201350346013400151640ustar0000000000000000use super::*; use ascii_canvas::AsciiView; use std::cmp; #[derive(Debug)] pub struct Wrap { items: Vec>, } impl Wrap { pub fn new(items: Vec>) -> Self { let mut wrap_items = vec![]; for item in items { item.into_wrap_items(&mut wrap_items); } Wrap { items: wrap_items } } } impl Content for Wrap { fn min_width(&self) -> usize { self.items.iter().map(|c| c.min_width()).max().unwrap() } fn emit(&self, view: &mut dyn AsciiView) { let columns = view.columns(); let mut row = 0; // current row let mut height = 1; // max height of anything in this row let mut column = 0; // current column in this row for item in &self.items { let len = item.min_width(); // If we don't have enough space for this content, // then move to the next line. if column + len > columns { column = 0; row += height; height = 1; } assert!(column + len <= columns); let (c_row, c_column) = item.emit_at(view, row, column); assert!(c_column >= column); column = c_column + 2; height = cmp::max(c_row - row + 1, height); } } fn into_wrap_items(self: Box, wrap_items: &mut Vec>) { wrap_items.extend(self.items); // `items` are already subdivided } } lalrpop-0.17.2/src/normalize/inline/graph/mod.rs000064400000000000000000000075601346406170700177530ustar0000000000000000#![allow(dead_code)] use collections::{map, Map}; use grammar::consts::INLINE; use grammar::repr::*; use normalize::{NormError, NormResult}; use petgraph::graph::{Graph, NodeIndex}; use string_cache::DefaultAtom as Atom; #[cfg(test)] mod test; /// Computes the proper order to inline the various nonterminals in /// `grammar`. Reports an error if there is an inline /// cycle. Otherwise, yields an ordering such that we inline X before /// Y if Y references X. I actually think it doesn't matter what /// order we do the inlining, really, but this order seems better /// somehow. :) (That is, inline into something before we inline it.) pub fn inline_order(grammar: &Grammar) -> NormResult> { let mut graph = NonterminalGraph::new(grammar); graph.create_nodes(); graph.add_edges(); graph.inline_order() } struct NonterminalGraph<'grammar> { grammar: &'grammar Grammar, graph: Graph, nonterminal_map: Map, } #[derive(Copy, Clone)] enum WalkState { NotVisited, Visiting, Visited, } impl<'grammar> NonterminalGraph<'grammar> { fn new(grammar: &'grammar Grammar) -> NonterminalGraph<'grammar> { NonterminalGraph { grammar, graph: Graph::new(), nonterminal_map: map(), } } fn create_nodes(&mut self) { let inline = Atom::from(INLINE); for (name, data) in &self.grammar.nonterminals { if data.annotations.iter().any(|a| a.id == inline) { let index = self.graph.add_node(name.clone()); self.nonterminal_map.insert(name.clone(), index); } } } fn add_edges(&mut self) { for production in self .grammar .nonterminals .values() .flat_map(|d| &d.productions) { let from_index = match self.nonterminal_map.get(&production.nonterminal) { Some(&index) => index, None => continue, // this is not an inlined nonterminal }; for symbol in &production.symbols { match *symbol { Symbol::Nonterminal(ref to) => { if let Some(&to_index) = self.nonterminal_map.get(to) { self.graph.add_edge(from_index, to_index, ()); } } Symbol::Terminal(_) => {} } } } } fn inline_order(&self) -> NormResult> { let mut states = vec![WalkState::NotVisited; self.graph.node_count()]; let mut result = vec![]; for node in self.nonterminal_map.values().cloned() { self.walk(&mut states, &mut result, node)?; } Ok(result) } fn walk( &self, states: &mut Vec, result: &mut Vec, source: NodeIndex, ) -> NormResult<()> { let nt = self.graph.node_weight(source).unwrap(); match states[source.index()] { WalkState::NotVisited => { states[source.index()] = WalkState::Visiting; for target in self.graph.neighbors(source) { self.walk(states, result, target)?; } states[source.index()] = WalkState::Visited; result.push(nt.clone()); Ok(()) } WalkState::Visited => Ok(()), WalkState::Visiting => { return_err!( self.grammar.nonterminals[&nt].span, "cyclic inline directive: `{}` would have to be inlined into itself", nt ); } } } } lalrpop-0.17.2/src/normalize/inline/graph/test.rs000064400000000000000000000024731341573331700201500ustar0000000000000000use super::inline_order; use grammar::repr::NonterminalString; use normalize::lower_helper; use parser; use session::Session; use string_cache::DefaultAtom as Atom; #[test] fn test_inline_self_cycle() { let grammar = parser::parse_grammar( r#" grammar; extern { } #[inline] A: () = A; "#, ) .unwrap(); let grammar = lower_helper(&Session::test(), grammar, true).unwrap(); assert!(inline_order(&grammar).is_err()); } #[test] fn test_inline_cycle_3() { let grammar = parser::parse_grammar( r#" grammar; extern { } #[inline] A: () = B; #[inline] B: () = C; #[inline] C: () = A; "#, ) .unwrap(); let grammar = lower_helper(&Session::test(), grammar, true).unwrap(); assert!(inline_order(&grammar).is_err()); } #[test] fn test_inline_order() { // because C references A, we inline A first. let grammar = parser::parse_grammar( r#" grammar; extern { } #[inline] A: () = B; B: () = C; #[inline] C: () = A; "#, ) .unwrap(); let grammar = lower_helper(&Session::test(), grammar, true).unwrap(); let a = NonterminalString(Atom::from("A")); let c = NonterminalString(Atom::from("C")); assert_eq!(inline_order(&grammar).unwrap(), vec![a, c]); } lalrpop-0.17.2/src/normalize/inline/mod.rs000064400000000000000000000136371346406170700166540ustar0000000000000000//! Inlining of nonterminals use grammar::repr::*; use normalize::NormResult; mod graph; #[cfg(test)] mod test; pub fn inline(mut grammar: Grammar) -> NormResult { let order = graph::inline_order(&grammar)?; for nt in order { inline_nt(&mut grammar, &nt); } Ok(grammar) } fn inline_nt(grammar: &mut Grammar, inline_nt: &NonterminalString) { let inline_productions = grammar.productions_for(inline_nt).to_vec(); for data in grammar.nonterminals.values_mut() { let mut new_productions = vec![]; let mut new_action_fn_defns = vec![]; for into_production in &data.productions { if !into_production .symbols .contains(&Symbol::Nonterminal(inline_nt.clone())) { new_productions.push(into_production.clone()); continue; } let mut inliner = Inliner { action_fn_defns: &grammar.action_fn_defns, inline_nonterminal: inline_nt.clone(), into_production, inline_fallible: 0, inline_productions: &inline_productions, new_symbols: vec![], new_productions: &mut new_productions, new_action_fn_defns: &mut new_action_fn_defns, }; inliner.inline(&into_production.symbols); } data.productions = new_productions; grammar.action_fn_defns.extend(new_action_fn_defns); } } struct Inliner<'a> { /// Action fn defns action_fn_defns: &'a [ActionFnDefn], /// The nonterminal `A` being inlined inline_nonterminal: NonterminalString, /// The full set of productions `A = B C D | E F G` for the /// nonterminal `A` being inlined inline_productions: &'a [Production], /// Number of actions that we have inlined for `A` so far which /// have been fallible. IOW, if we are inlining `A` into `X = Y A /// A Z`, and in the first instance of `A` we used a fallible /// action, but the second we used an infallible one, count would /// be 1. inline_fallible: u32, /// The `X = Y A Z` being inlined into into_production: &'a Production, /// The list of symbols we building up for the new production. /// For example, this would (eventually) contain `Y B C D Z`, /// given our running example. new_symbols: Vec, /// The output vector of all productions for `X` that we have created new_productions: &'a mut Vec, /// Vector of all action fn defns from the grammar. new_action_fn_defns: &'a mut Vec, } impl<'a> Inliner<'a> { fn inline(&mut self, into_symbols: &[Symbol]) { if into_symbols.is_empty() { // create an action fn for the result of inlining let into_action = self.into_production.action; let into_fallible = self.action_fn_defns[into_action.index()].fallible; let into_ret_type = self.action_fn_defns[into_action.index()].ret_type.clone(); let inline_fallible = self.inline_fallible != 0; let index = self.action_fn_defns.len() + self.new_action_fn_defns.len(); let action_fn = ActionFn::new(index); let inline_defn = InlineActionFnDefn { action: into_action, symbols: self.new_symbols.clone(), }; self.new_action_fn_defns.push(ActionFnDefn { fallible: into_fallible || inline_fallible, ret_type: into_ret_type, kind: ActionFnDefnKind::Inline(inline_defn), }); let prod_symbols: Vec = self .new_symbols .iter() .flat_map(|sym| match *sym { InlinedSymbol::Original(ref s) => vec![s.clone()], InlinedSymbol::Inlined(_, ref s) => s.clone(), }) .collect(); self.new_productions.push(Production { nonterminal: self.into_production.nonterminal.clone(), span: self.into_production.span, symbols: prod_symbols, action: action_fn, }); } else { let next_symbol = &into_symbols[0]; match *next_symbol { Symbol::Nonterminal(ref n) if *n == self.inline_nonterminal => { // Replace the current symbol with each of the // `inline_productions` in turn. for inline_production in self.inline_productions { // If this production is fallible, increment // count of fallible actions. let inline_action = inline_production.action; let fallible = self.action_fn_defns[inline_action.index()].fallible; self.inline_fallible += fallible as u32; // Push the symbols of the production inline. self.new_symbols.push(InlinedSymbol::Inlined( inline_production.action, inline_production.symbols.clone(), )); // Inline remaining symbols: self.inline(&into_symbols[1..]); // Reset state after we have inlined remaining symbols: self.new_symbols.pop(); self.inline_fallible -= fallible as u32; } } _ => { self.new_symbols .push(InlinedSymbol::Original(next_symbol.clone())); self.inline(&into_symbols[1..]); self.new_symbols.pop(); } } } } } lalrpop-0.17.2/src/normalize/inline/test.rs000064400000000000000000000046701341573331700170500ustar0000000000000000use grammar::parse_tree::NonterminalString; use grammar::repr::Grammar; use normalize::{self, NormResult}; use parser; use session::Session; use string_cache::DefaultAtom as Atom; use super::inline; fn inlined_grammar(text: &str) -> NormResult { let g = parser::parse_grammar(text).unwrap(); let g = normalize::lower_helper(&Session::test(), g, true).unwrap(); inline(g) } #[test] fn sri() { // This grammar gets a shift-reduce conflict because if the input // is "&" (*) "L", then we see two possibilities, and we must decide // between them: // // "&" (*) "L" E // | | | // +-------+--| // | // E // // or // // "&" (*) "L" // | | // | OPT_L E // | | | // +---+---+----+ // | // E // // to some extent this may be a false conflict, in that inlined // rules would address it, but it's an interesting one for // producing a useful error message. let grammar = inlined_grammar( r#" grammar; E: () = { "L", "&" OPT_L E }; #[inline] OPT_L: () = { (), "L" }; "#, ) .unwrap(); let nt = NonterminalString(Atom::from("E")); // After inlining, we expect: // // E = "L" // E = "&" E // E = "&" "L" E // // Note that the `()` also gets inlined. let e_productions = grammar.productions_for(&nt); assert_eq!(e_productions.len(), 3); assert_eq!(format!("{:?}", e_productions[0].symbols), r#"["L"]"#); assert_eq!(format!("{:?}", e_productions[1].symbols), r#"["&", E]"#); assert_eq!( format!("{:?}", e_productions[2].symbols), r#"["&", "L", E]"# ); } #[test] fn issue_55() { let grammar = inlined_grammar( r#" grammar; pub E: () = { "X" "{" "}" => () }; AT: () = { "type" ";" => () }; ET: () = { "enum" "{" "}" => () }; "#, ) .unwrap(); let nt = NonterminalString(Atom::from("E")); // The problem in issue #55 was that we would inline both `AT*` // the same way, so we ended up with `E = X { ET }` and `E = X { // AT+ ET AT+ }` but not `E = X { AT+ ET }` or `E = X { ET AT+ }`. assert!(grammar.productions_for(&nt).len() == 4); } lalrpop-0.17.2/src/normalize/lower/mod.rs000064400000000000000000000464451352730432300165230ustar0000000000000000//! Lower //! use collections::{map, Map}; use grammar::consts::CFG; use grammar::parse_tree as pt; use grammar::parse_tree::{ read_algorithm, GrammarItem, InternToken, Lifetime, NonterminalString, Path, TerminalString, Name }; use grammar::pattern::{Pattern, PatternKind}; use grammar::repr as r; use normalize::norm_util::{self, Symbols}; use normalize::NormResult; use session::Session; use string_cache::DefaultAtom as Atom; pub fn lower(session: &Session, grammar: pt::Grammar, types: r::Types) -> NormResult { let state = LowerState::new(session, types, &grammar); state.lower(grammar) } struct LowerState<'s> { session: &'s Session, prefix: String, action_fn_defns: Vec, nonterminals: Map, conversions: Vec<(TerminalString, Pattern)>, intern_token: Option, types: r::Types, uses_error_recovery: bool, } impl<'s> LowerState<'s> { fn new(session: &'s Session, types: r::Types, grammar: &pt::Grammar) -> Self { LowerState { session, prefix: grammar.prefix.clone(), action_fn_defns: vec![], nonterminals: map(), conversions: vec![], types, intern_token: None, uses_error_recovery: false, } } fn lower(mut self, grammar: pt::Grammar) -> NormResult { let start_symbols = self.synthesize_start_symbols(&grammar); let mut uses = vec![]; let mut token_span = None; let internal_token_path = Path { absolute: false, ids: vec![Atom::from("Token")], }; for item in grammar.items { match item { pt::GrammarItem::Use(data) => { uses.push(data); } pt::GrammarItem::MatchToken(_) => { // The declarations in the match token are handled // fully by the `token_check` when it constructs the // `InternToken` -- there is nothing left to do here. } pt::GrammarItem::InternToken(data) => { token_span = Some(grammar.span); let span = grammar.span; let input_str = r::TypeRepr::Ref { lifetime: Some(Lifetime::input()), mutable: false, referent: Box::new(r::TypeRepr::Nominal(r::NominalTypeRepr { path: r::Path::str(), types: vec![], })), }; self.conversions .extend(data.match_entries.iter().enumerate().map( |(index, match_entry)| { let pattern = Pattern { span, kind: PatternKind::TupleStruct( internal_token_path.clone(), vec![ Pattern { span, kind: PatternKind::Usize(index), }, Pattern { span, kind: PatternKind::Choose(input_str.clone()), }, ], ), }; (match_entry.user_name.clone(), pattern) }, )); self.intern_token = Some(data); } pt::GrammarItem::ExternToken(data) => { if let Some(enum_token) = data.enum_token { token_span = Some(enum_token.type_span); self.conversions .extend(enum_token.conversions.iter().map(|conversion| { ( conversion.from.clone(), conversion.to.map(&mut |t| t.type_repr()), ) })); } } pt::GrammarItem::Nonterminal(nt) => { let nt_name = &nt.name; let productions: Vec<_> = nt .alternatives .into_iter() .map(|alt| { let nt_type = self.types.nonterminal_type(nt_name).clone(); let symbols = self.symbols(&alt.expr.symbols); let action = self.action_kind(nt_type, &alt.expr, &symbols, alt.action); r::Production { nonterminal: nt_name.clone(), span: alt.span, symbols, action, } }) .collect(); self.nonterminals.insert( nt_name.clone(), r::NonterminalData { name: nt_name.clone(), visibility: nt.visibility.clone(), annotations: nt.annotations, span: nt.span, productions, }, ); } } } let parameters = grammar .parameters .iter() .map(|p| r::Parameter { name: p.name.clone(), ty: p.ty.type_repr(), }) .collect(); let where_clauses = grammar .where_clauses .iter() .flat_map(|wc| self.lower_where_clause(wc)) .collect(); let mut algorithm = r::Algorithm::default(); // FIXME Error recovery only works for parse tables so temporarily only generate parse tables for // testing if self.session.unit_test && !self.uses_error_recovery { algorithm.codegen = r::LrCodeGeneration::TestAll; } read_algorithm(&grammar.annotations, &mut algorithm); let mut all_terminals: Vec<_> = self .conversions .iter() .map(|c| c.0.clone()) .chain(if self.uses_error_recovery { Some(TerminalString::Error) } else { None }) .collect(); all_terminals.sort(); let terminal_bits: Map<_, _> = all_terminals.iter().cloned().zip(0..).collect(); Ok(r::Grammar { uses_error_recovery: self.uses_error_recovery, prefix: self.prefix, start_nonterminals: start_symbols, uses, action_fn_defns: self.action_fn_defns, nonterminals: self.nonterminals, conversions: self.conversions.into_iter().collect(), types: self.types, token_span: token_span.unwrap(), type_parameters: grammar.type_parameters, parameters, where_clauses, algorithm, intern_token: self.intern_token, terminals: r::TerminalSet { all: all_terminals, bits: terminal_bits, }, module_attributes: grammar.module_attributes, }) } fn synthesize_start_symbols( &mut self, grammar: &pt::Grammar, ) -> Map { let session = self.session; grammar .items .iter() .filter_map(GrammarItem::as_nonterminal) .filter(|nt| nt.visibility.is_pub()) .filter(|nt| cfg_active(session, nt)) .map(|nt| { // create a synthetic symbol `__Foo` for each public symbol `Foo` // with a rule like: // // __Foo = Foo; let fake_name = pt::NonterminalString(Atom::from(format!("{}{}", self.prefix, nt.name))); let nt_type = self.types.nonterminal_type(&nt.name).clone(); self.types.add_type(fake_name.clone(), nt_type.clone()); let expr = pt::ExprSymbol { symbols: vec![pt::Symbol::new( nt.span, pt::SymbolKind::Nonterminal(fake_name.clone()), )], }; let symbols = vec![r::Symbol::Nonterminal(nt.name.clone())]; let action_fn = self.action_fn(nt_type, false, &expr, &symbols, None); let production = r::Production { nonterminal: fake_name.clone(), symbols, action: action_fn, span: nt.span, }; self.nonterminals.insert( fake_name.clone(), r::NonterminalData { name: fake_name.clone(), visibility: nt.visibility.clone(), annotations: vec![], span: nt.span, productions: vec![production], }, ); (nt.name.clone(), fake_name) }) .collect() } /// When we lower where clauses into `repr::WhereClause`, they get /// flattened; so we may go from `T: Foo + Bar` into `[T: Foo, T: /// Bar]`. We also convert to `TypeRepr` and so forth. fn lower_where_clause(&mut self, wc: &pt::WhereClause) -> Vec { match wc { pt::WhereClause::Lifetime { lifetime, bounds } => bounds .iter() .map(|bound| r::WhereClause::Bound { subject: r::TypeRepr::Lifetime(lifetime.clone()), bound: pt::TypeBound::Lifetime(bound.clone()), }) .collect(), pt::WhereClause::Type { forall, ty, bounds } => bounds .iter() .map(|bound| r::WhereClause::Bound { subject: ty.type_repr(), bound: bound.map(pt::TypeRef::type_repr), }) .map(|bound| { if forall.is_empty() { bound } else { r::WhereClause::Forall { binder: forall.clone(), clause: Box::new(bound), } } }) .collect(), } } fn action_kind( &mut self, nt_type: r::TypeRepr, expr: &pt::ExprSymbol, symbols: &[r::Symbol], action: Option, ) -> r::ActionFn { match action { Some(pt::ActionKind::Lookahead) => self.lookahead_action_fn(), Some(pt::ActionKind::Lookbehind) => self.lookbehind_action_fn(), Some(pt::ActionKind::User(string)) => { self.action_fn(nt_type, false, &expr, &symbols, Some(string)) } Some(pt::ActionKind::Fallible(string)) => { self.action_fn(nt_type, true, &expr, &symbols, Some(string)) } None => self.action_fn(nt_type, false, &expr, &symbols, None), } } fn lookahead_action_fn(&mut self) -> r::ActionFn { let action_fn_defn = r::ActionFnDefn { fallible: false, ret_type: self.types.terminal_loc_type(), kind: r::ActionFnDefnKind::Lookaround(r::LookaroundActionFnDefn::Lookahead), }; self.add_action_fn(action_fn_defn) } fn lookbehind_action_fn(&mut self) -> r::ActionFn { let action_fn_defn = r::ActionFnDefn { fallible: false, ret_type: self.types.terminal_loc_type(), kind: r::ActionFnDefnKind::Lookaround(r::LookaroundActionFnDefn::Lookbehind), }; self.add_action_fn(action_fn_defn) } fn action_fn( &mut self, nt_type: r::TypeRepr, fallible: bool, expr: &pt::ExprSymbol, symbols: &[r::Symbol], action: Option, ) -> r::ActionFn { let action = match action { Some(s) => s, None => { // If the user declared a type `()`, or we inferred // it, then there is only one possible action that // will type-check (`()`), so supply that. Otherwise, // default is to include all selected items. if nt_type.is_unit() { "()".to_string() } else { "(<>)".to_string() } } }; // Note that the action fn takes ALL of the symbols in `expr` // as arguments, and some of them are simply dropped based on // the user's selections. // The set of argument types is thus the type of all symbols: let arg_types: Vec = symbols.iter().map(|s| s.ty(&self.types)).cloned().collect(); let action_fn_defn = match norm_util::analyze_expr(expr) { Symbols::Named(names) => { // if there are named symbols, we want to give the // arguments the names that the user gave them: let arg_names = names .iter() .map(|(index, name, _)| (*index, name.clone())); let arg_patterns = patterns( arg_names, symbols.len(), ); let action = { match norm_util::check_between_braces(&action) { norm_util::Presence::None => action, norm_util::Presence::Normal => { let name_str: String = { let name_strs: Vec<_> = names .iter() .map(|&(_, ref name, _)| name.name.as_ref()) .collect(); name_strs.join(", ") }; action.replace("<>", &name_str) } norm_util::Presence::InCurlyBrackets => { let name_str = { let name_strs: Vec<_> = names .iter() .map(|&(_, ref name, _)| format!("{0}:{0}", &*name.name)) .collect(); name_strs.join(", ") }; action.replace("<>", &name_str) } } }; r::ActionFnDefn { fallible, ret_type: nt_type, kind: r::ActionFnDefnKind::User(r::UserActionFnDefn { arg_patterns, arg_types, code: action, }), } } Symbols::Anon(indices) => { let names: Vec<_> = (0..indices.len()).map(|i| self.fresh_name(i)).collect(); let p_indices = indices.iter().map(|&(index, _)| index); let p_names = names.iter().cloned().map(Name::immut); let arg_patterns = patterns( p_indices.zip(p_names), symbols.len(), ); let name_str = { let name_strs: Vec<_> = names.iter().map(AsRef::as_ref).collect(); name_strs.join(", ") }; let action = action.replace("<>", &name_str); r::ActionFnDefn { fallible, ret_type: nt_type, kind: r::ActionFnDefnKind::User(r::UserActionFnDefn { arg_patterns, arg_types, code: action, }), } } }; self.add_action_fn(action_fn_defn) } fn add_action_fn(&mut self, action_fn_defn: r::ActionFnDefn) -> r::ActionFn { let index = r::ActionFn::new(self.action_fn_defns.len()); self.action_fn_defns.push(action_fn_defn); index } fn symbols(&mut self, symbols: &[pt::Symbol]) -> Vec { symbols.iter().map(|sym| self.symbol(sym)).collect() } fn symbol(&mut self, symbol: &pt::Symbol) -> r::Symbol { match symbol.kind { pt::SymbolKind::Terminal(ref id) => r::Symbol::Terminal(id.clone()), pt::SymbolKind::Nonterminal(ref id) => r::Symbol::Nonterminal(id.clone()), pt::SymbolKind::Choose(ref s) | pt::SymbolKind::Name(_, ref s) => self.symbol(s), pt::SymbolKind::Error => { self.uses_error_recovery = true; r::Symbol::Terminal(TerminalString::Error) } pt::SymbolKind::Macro(..) | pt::SymbolKind::Repeat(..) | pt::SymbolKind::Expr(..) | pt::SymbolKind::AmbiguousId(_) | pt::SymbolKind::Lookahead | pt::SymbolKind::Lookbehind => unreachable!( "symbol `{}` should have been normalized away by now", symbol ), } } fn fresh_name(&self, i: usize) -> Atom { Atom::from(format!("{}{}", self.prefix, i)) } } fn patterns(mut chosen: I, num_args: usize) -> Vec where I: Iterator, { let blank = Atom::from("_"); let mut next_chosen = chosen.next(); let result = (0..num_args) .map(|index| match next_chosen.clone() { Some((chosen_index, ref chosen_name)) if chosen_index == index => { next_chosen = chosen.next(); chosen_name.clone() } _ => Name::immut(blank.clone()), }) .collect(); debug_assert!(next_chosen.is_none()); result } fn cfg_active(session: &Session, nt: &pt::NonterminalData) -> bool { let cfg_atom = Atom::from(CFG); nt.annotations .iter() .filter(|ann| ann.id == cfg_atom) .all(|ann| { ann.arg.as_ref().map_or(false, |&(_, ref feature)| { session .features .as_ref() .map_or(false, |features| features.contains(feature)) }) }) } lalrpop-0.17.2/src/normalize/macro_expand/mod.rs000064400000000000000000000535521352730432300200300ustar0000000000000000use grammar::consts::INLINE; use grammar::parse_tree::{ ActionKind, Alternative, Annotation, Condition, ConditionOp, ExprSymbol, Grammar, GrammarItem, MacroSymbol, Name, NonterminalData, NonterminalString, Path, RepeatOp, RepeatSymbol, Span, Symbol, SymbolKind, TerminalLiteral, TerminalString, TypeRef, Visibility, }; use normalize::norm_util::{self, Symbols}; use normalize::resolve; use normalize::{NormError, NormResult}; use regex::Regex; use std::collections::{HashMap, HashSet}; use std::mem; use string_cache::DefaultAtom as Atom; #[cfg(test)] mod test; pub fn expand_macros(input: Grammar) -> NormResult { let input = resolve::resolve(input)?; let items = input.items; let (macro_defs, mut items): (Vec<_>, Vec<_>) = items.into_iter().partition(GrammarItem::is_macro_def); let macro_defs: HashMap<_, _> = macro_defs .into_iter() .map(|md| match md { GrammarItem::Nonterminal(ref data) => (data.name.clone(), data.clone()), _ => unreachable!(), }) .collect(); let mut expander = MacroExpander::new(macro_defs); expander.expand(&mut items)?; Ok(Grammar { items, ..input }) } struct MacroExpander { macro_defs: HashMap, expansion_set: HashSet, expansion_stack: Vec, } impl MacroExpander { fn new(macro_defs: HashMap) -> MacroExpander { MacroExpander { macro_defs, expansion_stack: Vec::new(), expansion_set: HashSet::new(), } } fn expand(&mut self, items: &mut Vec) -> NormResult<()> { let mut counter = 0; loop { // Find any macro uses in items added since last round and // replace them in place with the expanded version: for item in &mut items[counter..] { self.replace_item(item); } counter = items.len(); // No more expansion to do. if self.expansion_stack.is_empty() { return Ok(()); } // Drain expansion stack: while let Some(sym) = self.expansion_stack.pop() { match sym.kind { SymbolKind::Macro(msym) => { items.push(self.expand_macro_symbol(sym.span, msym)?) } SymbolKind::Expr(expr) => items.push(self.expand_expr_symbol(sym.span, expr)?), SymbolKind::Repeat(repeat) => { items.push(self.expand_repeat_symbol(sym.span, *repeat)?) } SymbolKind::Lookahead => items.push(self.expand_lookaround_symbol( sym.span, "@L", ActionKind::Lookahead, )?), SymbolKind::Lookbehind => items.push(self.expand_lookaround_symbol( sym.span, "@R", ActionKind::Lookbehind, )?), _ => panic!("don't know how to expand `{:?}`", sym), } } } } fn replace_item(&mut self, item: &mut GrammarItem) { match *item { GrammarItem::MatchToken(..) => {} GrammarItem::ExternToken(..) => {} GrammarItem::InternToken(..) => {} GrammarItem::Use(..) => {} GrammarItem::Nonterminal(ref mut data) => { // Should not encounter macro definitions here, // they've already been siphoned off. assert!(!data.is_macro_def()); for alternative in &mut data.alternatives { self.replace_symbols(&mut alternative.expr.symbols); } } } } fn replace_symbols(&mut self, symbols: &mut [Symbol]) { for symbol in symbols { self.replace_symbol(symbol); } } fn replace_symbol(&mut self, symbol: &mut Symbol) { match symbol.kind { SymbolKind::AmbiguousId(ref id) => { panic!("ambiguous id `{}` encountered after name resolution", id) } SymbolKind::Macro(ref mut m) => { for sym in &mut m.args { self.replace_symbol(sym); } } SymbolKind::Expr(ref mut expr) => { self.replace_symbols(&mut expr.symbols); } SymbolKind::Repeat(ref mut repeat) => { self.replace_symbol(&mut repeat.symbol); } SymbolKind::Terminal(_) | SymbolKind::Nonterminal(_) | SymbolKind::Error => { return; } SymbolKind::Choose(ref mut sym) | SymbolKind::Name(_, ref mut sym) => { self.replace_symbol(sym); return; } SymbolKind::Lookahead | SymbolKind::Lookbehind => {} } // only symbols we intend to expand fallthrough to here let key = NonterminalString(Atom::from(symbol.canonical_form())); let replacement = Symbol { span: symbol.span, kind: SymbolKind::Nonterminal(key.clone()), }; let to_expand = mem::replace(symbol, replacement); if self.expansion_set.insert(key) { self.expansion_stack.push(to_expand); } } /////////////////////////////////////////////////////////////////////////// // Macro expansion fn expand_macro_symbol(&mut self, span: Span, msym: MacroSymbol) -> NormResult { let msym_name = NonterminalString(Atom::from(msym.canonical_form())); let mdef = match self.macro_defs.get(&msym.name) { Some(v) => v, None => return_err!(span, "no macro definition found for `{}`", msym.name), }; if mdef.args.len() != msym.args.len() { return_err!( span, "expected {} arguments to `{}` but found {}", mdef.args.len(), msym.name, msym.args.len() ); } let args: HashMap = mdef .args .iter() .cloned() .zip(msym.args.into_iter().map(|s| s.kind)) .collect(); let type_decl = mdef .type_decl .as_ref() .map(|tr| self.macro_expand_type_ref(&args, tr)); // due to the use of `?`, it's a bit awkward to write this with an iterator let mut alternatives: Vec = vec![]; for alternative in &mdef.alternatives { if !self.evaluate_cond(&args, &alternative.condition)? { continue; } alternatives.push(Alternative { span, expr: self.macro_expand_expr_symbol(&args, &alternative.expr), condition: None, action: alternative.action.clone(), }); } Ok(GrammarItem::Nonterminal(NonterminalData { visibility: mdef.visibility.clone(), span, name: msym_name, annotations: mdef.annotations.clone(), args: vec![], type_decl, alternatives, })) } fn macro_expand_type_refs( &self, args: &HashMap, type_refs: &[TypeRef], ) -> Vec { type_refs .iter() .map(|tr| self.macro_expand_type_ref(args, tr)) .collect() } fn macro_expand_type_ref( &self, args: &HashMap, type_ref: &TypeRef, ) -> TypeRef { match *type_ref { TypeRef::Tuple(ref trs) => TypeRef::Tuple(self.macro_expand_type_refs(args, trs)), TypeRef::Nominal { ref path, ref types, } => TypeRef::Nominal { path: path.clone(), types: self.macro_expand_type_refs(args, types), }, TypeRef::Lifetime(ref id) => TypeRef::Lifetime(id.clone()), TypeRef::OfSymbol(ref sym) => TypeRef::OfSymbol(sym.clone()), TypeRef::Ref { ref lifetime, mutable, ref referent, } => TypeRef::Ref { lifetime: lifetime.clone(), mutable, referent: Box::new(self.macro_expand_type_ref(args, referent)), }, TypeRef::Id(ref id) => match args.get(&NonterminalString(id.clone())) { Some(sym) => TypeRef::OfSymbol(sym.clone()), None => TypeRef::Nominal { path: Path::from_id(id.clone()), types: vec![], }, }, TypeRef::TraitObject { ref path, ref types, } => TypeRef::TraitObject { path: path.clone(), types: self.macro_expand_type_refs(args, types), }, TypeRef::Fn { ref forall, ref path, ref parameters, ref ret, } => TypeRef::Fn { forall: forall.clone(), path: path.clone(), parameters: self.macro_expand_type_refs(args, parameters), ret: ret .as_ref() .map(|t| Box::new(self.macro_expand_type_ref(args, t))), }, } } fn evaluate_cond( &self, args: &HashMap, opt_cond: &Option, ) -> NormResult { if let Some(ref c) = *opt_cond { match args[&c.lhs] { SymbolKind::Terminal(TerminalString::Literal(TerminalLiteral::Quoted(ref lhs))) => { match c.op { ConditionOp::Equals => Ok(lhs == &c.rhs), ConditionOp::NotEquals => Ok(lhs != &c.rhs), ConditionOp::Match => self.re_match(c.span, lhs, &c.rhs), ConditionOp::NotMatch => Ok(!self.re_match(c.span, lhs, &c.rhs)?), } } ref lhs => { return_err!( c.span, "invalid condition LHS `{}`, expected a string literal, not `{}`", c.lhs, lhs ); } } } else { Ok(true) } } fn re_match(&self, span: Span, lhs: &Atom, regex: &Atom) -> NormResult { let re = match Regex::new(®ex) { Ok(re) => re, Err(err) => return_err!(span, "invalid regular expression `{}`: {}", regex, err), }; Ok(re.is_match(&lhs)) } fn macro_expand_symbols( &self, args: &HashMap, expr: &[Symbol], ) -> Vec { expr.iter() .map(|s| self.macro_expand_symbol(args, s)) .collect() } fn macro_expand_expr_symbol( &self, args: &HashMap, expr: &ExprSymbol, ) -> ExprSymbol { ExprSymbol { symbols: self.macro_expand_symbols(args, &expr.symbols), } } fn macro_expand_symbol( &self, args: &HashMap, symbol: &Symbol, ) -> Symbol { let kind = match symbol.kind { SymbolKind::Expr(ref expr) => { SymbolKind::Expr(self.macro_expand_expr_symbol(args, expr)) } SymbolKind::Terminal(ref id) => SymbolKind::Terminal(id.clone()), SymbolKind::Nonterminal(ref id) => match args.get(id) { Some(sym) => sym.clone(), None => SymbolKind::Nonterminal(id.clone()), }, SymbolKind::Macro(ref msym) => SymbolKind::Macro(MacroSymbol { name: msym.name.clone(), args: self.macro_expand_symbols(args, &msym.args), }), SymbolKind::Repeat(ref r) => SymbolKind::Repeat(Box::new(RepeatSymbol { op: r.op, symbol: self.macro_expand_symbol(args, &r.symbol), })), SymbolKind::Choose(ref sym) => { SymbolKind::Choose(Box::new(self.macro_expand_symbol(args, sym))) } SymbolKind::Name(ref id, ref sym) => SymbolKind::Name( Name::new(id.mutable, id.name.clone()), Box::new(self.macro_expand_symbol(args, sym)), ), SymbolKind::Lookahead => SymbolKind::Lookahead, SymbolKind::Lookbehind => SymbolKind::Lookbehind, SymbolKind::Error => SymbolKind::Error, SymbolKind::AmbiguousId(ref id) => { panic!("ambiguous id `{}` encountered after name resolution", id) } }; Symbol { span: symbol.span, kind, } } /////////////////////////////////////////////////////////////////////////// // Expr expansion fn expand_expr_symbol(&mut self, span: Span, expr: ExprSymbol) -> NormResult { let name = NonterminalString(Atom::from(expr.canonical_form())); let ty_ref = match norm_util::analyze_expr(&expr) { Symbols::Named(names) => { let (_, ref ex_id, ex_sym) = names[0]; return_err!( span, "named symbols like `{}:{}` are only allowed at the top-level of a nonterminal", ex_id, ex_sym) } Symbols::Anon(syms) => maybe_tuple( syms.into_iter() .map(|(_, s)| TypeRef::OfSymbol(s.kind.clone())) .collect(), ), }; Ok(GrammarItem::Nonterminal(NonterminalData { visibility: Visibility::Priv, span, name, annotations: inline(span), args: vec![], type_decl: Some(ty_ref), alternatives: vec![Alternative { span, expr, condition: None, action: action("(<>)"), }], })) } /////////////////////////////////////////////////////////////////////////// // Expr expansion fn expand_repeat_symbol( &mut self, span: Span, repeat: RepeatSymbol, ) -> NormResult { let name = NonterminalString(Atom::from(repeat.canonical_form())); let v = Atom::from("v"); let e = Atom::from("e"); let base_symbol_ty = TypeRef::OfSymbol(repeat.symbol.kind.clone()); match repeat.op { RepeatOp::Star => { let path = Path::vec(); let ty_ref = TypeRef::Nominal { path, types: vec![base_symbol_ty], }; let plus_repeat = Box::new(RepeatSymbol { op: RepeatOp::Plus, symbol: repeat.symbol.clone(), }); Ok(GrammarItem::Nonterminal(NonterminalData { visibility: Visibility::Priv, span, name, annotations: inline(span), args: vec![], type_decl: Some(ty_ref), alternatives: vec![ // X* = Alternative { span, expr: ExprSymbol { symbols: vec![] }, condition: None, action: action("vec![]"), }, // X* = Alternative { span, expr: ExprSymbol { symbols: vec![Symbol::new( span, SymbolKind::Name( Name::immut(v), Box::new(Symbol::new( span, SymbolKind::Repeat(plus_repeat), )), ), )], }, condition: None, action: action("v"), }, ], })) } RepeatOp::Plus => { let path = Path::vec(); let ty_ref = TypeRef::Nominal { path, types: vec![base_symbol_ty], }; Ok(GrammarItem::Nonterminal(NonterminalData { visibility: Visibility::Priv, span, name: name.clone(), annotations: vec![], args: vec![], type_decl: Some(ty_ref), alternatives: vec![ // X+ = X Alternative { span, expr: ExprSymbol { symbols: vec![repeat.symbol.clone()], }, condition: None, action: action("vec![<>]"), }, // X+ = Alternative { span, expr: ExprSymbol { symbols: vec![ Symbol::new( span, SymbolKind::Name( Name::immut(v), Box::new(Symbol::new( span, SymbolKind::Nonterminal(name), )), ), ), Symbol::new( span, SymbolKind::Name( Name::immut(e), Box::new(repeat.symbol.clone()), ), ), ], }, condition: None, action: action("{ let mut v = v; v.push(e); v }"), }, ], })) } RepeatOp::Question => { let path = Path::option(); let ty_ref = TypeRef::Nominal { path, types: vec![base_symbol_ty], }; Ok(GrammarItem::Nonterminal(NonterminalData { visibility: Visibility::Priv, span, name, annotations: inline(span), args: vec![], type_decl: Some(ty_ref), alternatives: vec![ // X? = X => Some(<>) Alternative { span, expr: ExprSymbol { symbols: vec![repeat.symbol.clone()], }, condition: None, action: action("Some(<>)"), }, // X? = { => None; } Alternative { span, expr: ExprSymbol { symbols: vec![] }, condition: None, action: action("None"), }, ], })) } } } fn expand_lookaround_symbol( &mut self, span: Span, name: &str, action: ActionKind, ) -> NormResult { let name = NonterminalString(Atom::from(name)); Ok(GrammarItem::Nonterminal(NonterminalData { visibility: Visibility::Priv, span, name, annotations: inline(span), args: vec![], type_decl: None, alternatives: vec![Alternative { span, expr: ExprSymbol { symbols: vec![] }, condition: None, action: Some(action), }], })) } } fn maybe_tuple(v: Vec) -> TypeRef { if v.len() == 1 { v.into_iter().next().unwrap() } else { TypeRef::Tuple(v) } } fn action(s: &str) -> Option { Some(ActionKind::User(s.to_string())) } fn inline(span: Span) -> Vec { vec![Annotation { id_span: span, id: Atom::from(INLINE), arg: None, }] } lalrpop-0.17.2/src/normalize/macro_expand/test.rs000064400000000000000000000044271341573332000202240ustar0000000000000000use parser; use test_util::compare; use super::expand_macros; #[test] fn test_comma() { let grammar = parser::parse_grammar( r#" grammar; Comma: Vec = ",")*> => v.into_iter().chain(e.into_iter()).collect(); Ids = Comma<"Id">; "#, ) .unwrap(); let actual = expand_macros(grammar).unwrap(); let expected = parser::parse_grammar( r##" grammar; Ids = `Comma<"Id">`; `Comma<"Id">`: Vec<#"Id"#> = ",")*`> => v.into_iter().chain(e.into_iter()).collect(); #[inline] `"Id"?`: ::std::option::Option<#"Id"#> = { "Id" => Some(<>), => None }; #[inline] `(<"Id"> ",")*`: ::std::vec::Vec<#`(<"Id"> ",")`#> = { => vec![], ",")+`> => v, }; #[inline] `(<"Id"> ",")`: #"Id"# = { <"Id"> "," => (<>), }; `(<"Id"> ",")+`: ::std::vec::Vec<#`(<"Id"> ",")`#> = { `(<"Id"> ",")` => vec![<>], ",")+`> ",")`> => { let mut v = v; v.push(e); v }, }; "##, ) .unwrap(); compare(actual, expected); } #[test] fn test_if_match() { let grammar = parser::parse_grammar( r#" grammar; Expr = { "A" if E == "A*C", "B" if E ~~ "^A*C$", "C" if E != "A*C", "D" if E !~ "^A*C$" }; Expr1 = Expr<"A*C">; Expr2 = Expr<"AAC">; Expr3 = Expr<"ABC">; "#, ) .unwrap(); let actual = expand_macros(grammar).unwrap(); let expected = parser::parse_grammar( r#" grammar; Expr1 = `Expr<"A*C">`; Expr2 = `Expr<"AAC">`; Expr3 = `Expr<"ABC">`; `Expr<"ABC">` = { "C", "D" }; `Expr<"AAC">` = { "B", "C" }; `Expr<"A*C">` = { "A", "D" }; "#, ) .unwrap(); compare(actual, expected); } #[test] fn test_lookahead() { let grammar = parser::parse_grammar( r#" grammar; Expr = @L; "#, ) .unwrap(); let actual = expand_macros(grammar).unwrap(); let expected = parser::parse_grammar( r#" grammar; Expr = `@L`; #[inline] `@L` = =>@L; "#, ) .unwrap(); compare(actual, expected); } lalrpop-0.17.2/src/normalize/mod.rs000064400000000000000000000062121346406170700153650ustar0000000000000000//! Normalization processes a parse tree until it is in suitable form to //! be converted to the more canonical form. This is done as a series of //! passes, each contained in their own module below. use grammar::parse_tree as pt; use grammar::repr as r; use session::Session; pub type NormResult = Result; #[derive(Clone, Debug)] pub struct NormError { pub message: String, pub span: pt::Span, } macro_rules! return_err { ($span: expr, $($args:expr),+) => { return Err(NormError { message: format!($($args),+), span: $span }); } } pub fn normalize(session: &Session, grammar: pt::Grammar) -> NormResult { normalize_helper(session, grammar, true) } /// for unit tests, it is convenient to skip the validation step, and supply a dummy session #[cfg(test)] pub fn normalize_without_validating(grammar: pt::Grammar) -> NormResult { normalize_helper(&Session::new(), grammar, false) } fn normalize_helper( session: &Session, grammar: pt::Grammar, validate: bool, ) -> NormResult { let grammar = lower_helper(session, grammar, validate)?; let grammar = profile!(session, "Inlining", inline::inline(grammar)?); Ok(grammar) } fn lower_helper(session: &Session, grammar: pt::Grammar, validate: bool) -> NormResult { profile!( session, "Grammar validation", if validate { prevalidate::validate(&grammar)?; } ); let grammar = profile!(session, "Grammar resolution", resolve::resolve(grammar)?); let grammar = profile!( session, "Macro expansion", macro_expand::expand_macros(grammar)? ); let grammar = profile!(session, "Token check", token_check::validate(grammar)?); let types = profile!(session, "Infer types", tyinfer::infer_types(&grammar)?); let grammar = profile!(session, "Lowering", lower::lower(session, grammar, types)?); Ok(grammar) } // These are executed *IN ORDER*: // Check most safety conditions. mod prevalidate; // Resolve identifiers into terminals/nonterminals etc. mod resolve; // Expands macros and expressions // // X = ...1 Comma (X Y Z) ...2 // // to // // X = ...1 `Comma` `(X Y Z)` ...2 // `Comma_X`: Vec<> = ...; // `(X Y Z)` = X Y Z; // // AFTER THIS POINT: No more macros, macro references, guarded // alternatives, repeats, or expr symbols, though type indirections // may occur. mod macro_expand; // Check if there is an extern token and all terminals have have a // conversion; if no extern token, synthesize an intern token. mod token_check; // Computes types where the user omitted them (or from macro // byproducts). // // AFTER THIS POINT: there is a separate `repr::Types` table // providing all nonterminals with an explicit type. mod tyinfer; // Lowers the parse tree to the repr notation. mod lower; // Inline nonterminals that have requested it. mod inline; /////////////////////////////////////////////////////////////////////////// // Shared routines mod norm_util; lalrpop-0.17.2/src/normalize/norm_util.rs000064400000000000000000000103361352730432300166120ustar0000000000000000use grammar::parse_tree::{ActionKind, Alternative, ExprSymbol, Symbol, SymbolKind, Name}; #[derive(Debug)] pub enum AlternativeAction<'a> { User(&'a ActionKind), Default(Symbols<'a>), } #[derive(Debug)] pub enum Symbols<'a> { Named(Vec<(usize, Name, &'a Symbol)>), Anon(Vec<(usize, &'a Symbol)>), } pub fn analyze_action(alt: &Alternative) -> AlternativeAction<'_> { // We can't infer types for alternatives with actions if let Some(ref code) = alt.action { return AlternativeAction::User(code); } AlternativeAction::Default(analyze_expr(&alt.expr)) } pub fn analyze_expr(expr: &ExprSymbol) -> Symbols<'_> { // First look for named symbols. let named_symbols: Vec<_> = expr .symbols .iter() .enumerate() .filter_map(|(idx, sym)| match sym.kind { SymbolKind::Name(ref id, ref sub) => Some((idx, id.clone(), &**sub)), _ => None, }) .collect(); if !named_symbols.is_empty() { return Symbols::Named(named_symbols); } // Otherwise, make a tuple of the items they chose with `<>`. let chosen_symbol_types: Vec<_> = expr .symbols .iter() .enumerate() .filter_map(|(idx, sym)| match sym.kind { SymbolKind::Choose(ref sub) => Some((idx, &**sub)), _ => None, }) .collect(); if !chosen_symbol_types.is_empty() { return Symbols::Anon(chosen_symbol_types); } // If they didn't choose anything with `<>`, make a tuple of everything. Symbols::Anon(expr.symbols.iter().enumerate().collect()) } #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub enum Presence { None, InCurlyBrackets, Normal, } impl Presence { pub fn is_in_curly_brackets(self) -> bool { self == Presence::InCurlyBrackets } } pub fn check_between_braces(action: &str) -> Presence { if let Some(funky_index) = action.find("<>") { let (before, after) = { let (before, after) = action.split_at(funky_index); (before.trim(), after[2..].trim()) }; let last_before = before.chars().last(); let next_after = after.chars().next(); if let (Some('{'), Some('}')) = (last_before, next_after) { Presence::InCurlyBrackets } else { Presence::Normal } } else { Presence::None } } #[cfg(test)] mod test { use super::*; #[test] fn detecting_normal_funky_expression() { assert_eq!(Presence::Normal, check_between_braces("<>")); assert_eq!(Presence::Normal, check_between_braces("ble <> blaa")); assert_eq!(Presence::Normal, check_between_braces("ble <> } b")); assert_eq!(Presence::Normal, check_between_braces("bl{ e <> } b")); assert_eq!(Presence::Normal, check_between_braces("bl{ e <>} b")); assert_eq!(Presence::Normal, check_between_braces("bl{ e <> e } b")); assert_eq!(Presence::Normal, check_between_braces("bl{ <> e } b")); assert_eq!(Presence::Normal, check_between_braces("bl{<> e } b")); assert_eq!(Presence::Normal, check_between_braces("bl{<>")); assert_eq!(Presence::Normal, check_between_braces("<>}")); } #[test] fn detecting_nopresence_of_funky_expression() { assert_eq!(Presence::None, check_between_braces("< >")); assert_eq!(Presence::None, check_between_braces("ble blaa")); } #[test] fn detecting_incurlybrackets_funky_expression() { assert_eq!(Presence::InCurlyBrackets, check_between_braces("{<>}")); assert_eq!( Presence::InCurlyBrackets, check_between_braces("ble{<> }blaa") ); assert_eq!( Presence::InCurlyBrackets, check_between_braces("ble{ <> } b") ); assert_eq!( Presence::InCurlyBrackets, check_between_braces("bl{ <>} b") ); assert_eq!(Presence::InCurlyBrackets, check_between_braces("bl{<>} b")); assert_eq!( Presence::InCurlyBrackets, check_between_braces("bl{<> } b") ); } } lalrpop-0.17.2/src/normalize/prevalidate/mod.rs000064400000000000000000000306461352730432300176670ustar0000000000000000//! Validate checks some basic safety conditions. use super::norm_util::{self, Symbols}; use super::{NormError, NormResult}; use collections::{set, Multimap}; use grammar::consts::*; use grammar::parse_tree::*; use grammar::repr as r; use string_cache::DefaultAtom as Atom; use util::Sep; #[cfg(test)] mod test; pub fn validate(grammar: &Grammar) -> NormResult<()> { let match_token: Option<&MatchToken> = grammar .items .iter() .filter_map(GrammarItem::as_match_token) .next(); let extern_token: Option<&ExternToken> = grammar .items .iter() .filter_map(GrammarItem::as_extern_token) .next(); let validator = Validator { grammar, match_token, extern_token, }; validator.validate() } struct Validator<'grammar> { grammar: &'grammar Grammar, match_token: Option<&'grammar MatchToken>, extern_token: Option<&'grammar ExternToken>, } impl<'grammar> Validator<'grammar> { fn validate(&self) -> NormResult<()> { let allowed_names = vec![ Atom::from(LALR), Atom::from(TABLE_DRIVEN), Atom::from(RECURSIVE_ASCENT), Atom::from(TEST_ALL), ]; for annotation in &self.grammar.annotations { if !allowed_names.contains(&annotation.id) { return_err!( annotation.id_span, "unrecognized annotation `{}`", annotation.id ); } } for item in &self.grammar.items { match *item { GrammarItem::Use(..) => {} GrammarItem::MatchToken(ref data) => { if data.span != self.match_token.unwrap().span { return_err!(data.span, "multiple match definitions are not permitted"); } // Only error if a custom lexer is specified, having a custom types is ok if let Some(d) = self.extern_token { if d.enum_token.is_some() { return_err!( d.span, "extern (with custom tokens) and match definitions are mutually exclusive"); } } // Ensure that the catch all is final item of final block for (contents_idx, match_contents) in data.contents.iter().enumerate() { for (item_idx, item) in match_contents.items.iter().enumerate() { if item.is_catch_all() && (contents_idx != &data.contents.len() - 1 || item_idx != &match_contents.items.len() - 1) { return_err!(item.span(), "Catch all must be final item"); } } } } GrammarItem::ExternToken(ref data) => { if data.span != self.extern_token.unwrap().span { return_err!(data.span, "multiple extern definitions are not permitted"); } // Only error if a custom lexer is specified, having a custom types is ok if let Some(d) = self.match_token { if data.enum_token.is_some() { return_err!( d.span, "match and extern (with custom tokens) definitions are mutually exclusive"); } } let allowed_names = vec![Atom::from(LOCATION), Atom::from(ERROR)]; let mut new_names = set(); for associated_type in &data.associated_types { if !allowed_names.contains(&associated_type.type_name) { return_err!( associated_type.type_span, "associated type `{}` not recognized, \ try one of the following: {}", associated_type.type_name, Sep(", ", &allowed_names) ); } else if !new_names.insert(associated_type.type_name.clone()) { return_err!( associated_type.type_span, "associated type `{}` already specified", associated_type.type_name ); } } } GrammarItem::Nonterminal(ref data) => { if data.visibility.is_pub() && !data.args.is_empty() { return_err!(data.span, "macros cannot be marked public"); } let inline_annotation = Atom::from(INLINE); let cfg_annotation = Atom::from(CFG); let known_annotations = [inline_annotation.clone(), cfg_annotation.clone()]; let mut found_annotations = set(); for annotation in &data.annotations { if !known_annotations.contains(&annotation.id) { return_err!( annotation.id_span, "unrecognized annotation `{}`", annotation.id ); } else if !found_annotations.insert(annotation.id.clone()) { return_err!( annotation.id_span, "duplicate annotation `{}`", annotation.id ); } else if annotation.id == inline_annotation && data.visibility.is_pub() { return_err!( annotation.id_span, "public items cannot be marked #[inline]" ); } else if annotation.id == cfg_annotation { if data.visibility.is_pub() { match annotation.arg { Some((ref name, _)) if name == "feature" => (), _ => return_err!( annotation.id_span, r#"`cfg` annotations must have a `feature = "my_feature" argument"# ), } } else { return_err!( annotation.id_span, "private items cannot be marked #[cfg]" ); } } } for alternative in &data.alternatives { self.validate_alternative(alternative)?; } } GrammarItem::InternToken(..) => {} } } Ok(()) } fn validate_alternative(&self, alternative: &Alternative) -> NormResult<()> { self.validate_expr(&alternative.expr)?; match norm_util::analyze_expr(&alternative.expr) { Symbols::Named(syms) => { if alternative.action.is_none() { let sym = syms.iter().map(|&(_, _, sym)| sym).next().unwrap(); return_err!( sym.span, "named symbols (like `{}`) require a custom action", sym ); } } Symbols::Anon(_) => { let empty_string = "".to_string(); let action = { match alternative.action { Some(ActionKind::User(ref action)) => action, Some(ActionKind::Fallible(ref action)) => action, _ => &empty_string, } }; if norm_util::check_between_braces(action).is_in_curly_brackets() { return_err!( alternative.span, "Using `<>` between curly braces (e.g., `{{<>}}`) only works when your parsed values have been given names (e.g., ``, not just ``)"); } } } Ok(()) } fn validate_expr(&self, expr: &ExprSymbol) -> NormResult<()> { for symbol in &expr.symbols { self.validate_symbol(symbol)?; } let chosen: Vec<&Symbol> = expr .symbols .iter() .filter(|sym| match sym.kind { SymbolKind::Choose(_) => true, _ => false, }) .collect(); let named: Multimap> = expr .symbols .iter() .filter_map(|sym| match sym.kind { SymbolKind::Name(ref nt, _) => Some((nt.name.clone(), sym)), _ => None, }) .collect(); if !chosen.is_empty() && !named.is_empty() { return_err!( chosen[0].span, "anonymous symbols like this one cannot be combined with \ named symbols like `{}`", named.into_iter().next().unwrap().1[0] ); } for (name, syms) in named.into_iter() { if syms.len() > 1 { return_err!( syms[1].span, "multiple symbols named `{}` are not permitted", name ); } } Ok(()) } fn validate_symbol(&self, symbol: &Symbol) -> NormResult<()> { match symbol.kind { SymbolKind::Expr(ref expr) => { self.validate_expr(expr)?; } SymbolKind::AmbiguousId(_) => { /* see resolve */ } SymbolKind::Terminal(_) => { /* see postvalidate! */ } SymbolKind::Nonterminal(_) => { /* see resolve */ } SymbolKind::Error => { let mut algorithm = r::Algorithm::default(); read_algorithm(&self.grammar.annotations, &mut algorithm); if algorithm.codegen == r::LrCodeGeneration::RecursiveAscent { return_err!( symbol.span, "error recovery is not yet supported by recursive ascent parsers" ); } } SymbolKind::Macro(ref msym) => { debug_assert!(!msym.args.is_empty()); for arg in &msym.args { self.validate_symbol(arg)?; } } SymbolKind::Repeat(ref repeat) => { self.validate_symbol(&repeat.symbol)?; } SymbolKind::Choose(ref sym) | SymbolKind::Name(_, ref sym) => { self.validate_symbol(sym)?; } SymbolKind::Lookahead | SymbolKind::Lookbehind => { // if using an internal tokenizer, lookahead/lookbehind are ok. if let Some(extern_token) = self.extern_token { if extern_token.enum_token.is_some() { // otherwise, the Location type must be specified. let loc = Atom::from(LOCATION); if self.extern_token.unwrap().associated_type(loc).is_none() { return_err!( symbol.span, "lookahead/lookbehind require you to declare the type of \ a location; add a `type {} = ..` statement to the extern token \ block", LOCATION ); } } } } } Ok(()) } } lalrpop-0.17.2/src/normalize/prevalidate/test.rs000064400000000000000000000104141341573332000200550ustar0000000000000000use parser; use test_util; fn check_err(expected_err: &str, grammar: &str, span: &str) { let parsed_grammar = parser::parse_grammar(&grammar).unwrap(); let err = super::validate(&parsed_grammar).unwrap_err(); test_util::check_norm_err(expected_err, span, err); } #[test] fn named_symbols() { check_err( r#"named symbols \(like `"Num"`\) require a custom action"#, r#"grammar; Term = { };"#, r#" ~~~~~ "#, ); } #[test] fn bad_assoc_type() { check_err( r#"associated type `Foo` not recognized"#, r#"grammar; extern { type Foo = i32; enum Tok { } }"#, r#" ~~~ "#, ); } #[test] fn dup_assoc_type() { check_err( r#"associated type `Location` already specified"#, r#"grammar; extern { type Location = i32; type Location = u32; enum Tok { } }"#, r#" ~~~~~~~~ "#, ); } #[test] fn lookahead_without_loc_type() { check_err( r#"lookahead/lookbehind require you to declare the type of a location"#, r#"grammar; extern { enum Tok { } } Foo = @L;"#, r#" ~~ "#, ); } #[test] fn multiple_extern_token() { check_err( r#"multiple extern definitions are not permitted"#, r#"grammar; extern { enum Tok { } } extern { enum Tok { } }"#, r#" ~~~~~~ "#, ); } #[test] fn unrecognized_annotation() { check_err( r#"unrecognized annotation `foo`"#, r#"grammar; #[foo] Term = ();"#, r#" ~~~ "#, ); } #[test] fn duplicate_annotation() { check_err( r#"duplicate annotation `inline`"#, r#"grammar; #[inline] #[inline] Term = ();"#, r#" ~~~~~~ "#, ); } #[test] fn pub_inline_annotation() { check_err( r#"public items cannot be marked #\[inline\]"#, r#"grammar; #[inline] pub Term = ();"#, r#" ~~~~~~ "#, ); } #[test] fn multiple_match_token() { check_err( r#"multiple match definitions are not permitted"#, r#"grammar; match { _ } match { _ }"#, r#" ~~~~~ "#, ); } #[test] fn match_after_extern_token() { check_err( r#"match and extern \(with custom tokens\) definitions are mutually exclusive"#, r#"grammar; extern { enum Tok { } } match { _ }"#, r#" ~~~~~ "#, ); } #[test] fn extern_after_match_token() { check_err( r#"extern \(with custom tokens\) and match definitions are mutually exclusive"#, r#"grammar; match { _ } extern { enum Tok { } }"#, r#" ~~~~~~ "#, ); } #[test] fn match_catch_all_first_of_last() { check_err( r#"Catch all must be final item"#, r#"grammar; match { _, "abc" }"#, r#" ~ "#, ); } #[test] fn match_catch_all_last_of_first() { check_err( r#"Catch all must be final item"#, r#"grammar; match { "abc", _ } else { "foo" }"#, r#" ~ "#, ); } #[test] fn expandable_expression_requires_named_variables() { check_err( r#"Using `<>` between curly braces \(e.g., `\{<>\}`\) only works when your parsed values have been given names \(e.g., ``, not just ``\)"#, r#"grammar; Term = { => Foo {<>} };"#, r#" ~~~~~~~~~~~~~~~~ "#); } #[test] fn mixing_names_and_anonymous_values() { check_err( r#"anonymous symbols like this one cannot be combined with named symbols like `b:B`"#, r#"grammar; Term = { => Alien: Eighth passanger of Nostromo};"#, r#" ~~~ "#, ); } #[test] fn public_macros() { check_err( r#"macros cannot be marked public"#, r#"grammar; pub Comma = (T ",")* T?;"#, r#" ~~~~~~~~ "#, ); } lalrpop-0.17.2/src/normalize/resolve/mod.rs000064400000000000000000000241051346406170700170450ustar0000000000000000//! Resolves identifiers to decide if they are macros, terminals, or //! nonterminals. Rewrites the parse tree accordingly. use super::{NormError, NormResult}; use collections::{map, Map}; use grammar::parse_tree::*; use string_cache::DefaultAtom as Atom; #[cfg(test)] mod test; pub fn resolve(mut grammar: Grammar) -> NormResult { resolve_in_place(&mut grammar)?; Ok(grammar) } fn resolve_in_place(grammar: &mut Grammar) -> NormResult<()> { let globals = { let nonterminal_identifiers = grammar .items .iter() .filter_map(GrammarItem::as_nonterminal) .map(|nt| (nt.span, nt.name.0.clone(), Def::Nonterminal(nt.args.len()))); let terminal_identifiers = grammar .items .iter() .filter_map(GrammarItem::as_extern_token) .flat_map(|extern_token| extern_token.enum_token.as_ref()) .flat_map(|enum_token| &enum_token.conversions) .filter_map(|conversion| match conversion.from { TerminalString::Literal(..) | TerminalString::Error => None, TerminalString::Bare(ref id) => Some((conversion.span, id.clone(), Def::Terminal)), }); // Extract all the bare identifiers that appear in the RHS of a `match` declaration. // Example: // match { // r"(?)begin" => "BEGIN", // } else { // r"[a-zA-Z_][a-zA-Z0-9_]*" => ID, // } // This would result in `vec![ID]`. let match_identifiers = grammar .items .iter() .filter_map(GrammarItem::as_match_token) .flat_map(|match_token| &match_token.contents) .flat_map(|match_contents| &match_contents.items) .filter_map(|item| match *item { MatchItem::Mapped(_, TerminalString::Bare(ref id), _) => { Some((item.span(), id.clone(), Def::Terminal)) } _ => None, }); let all_identifiers = nonterminal_identifiers .chain(terminal_identifiers) .chain(match_identifiers); let mut identifiers = map(); for (span, id, def) in all_identifiers { if let Some(old_def) = identifiers.insert(id.clone(), def) { let description = def.description(); let old_description = old_def.description(); if description == old_description { return_err!(span, "two {}s declared with the name `{}`", description, id); } else { return_err!( span, "{} and {} both declared with the name `{}`", description, old_description, id ); } } } ScopeChain { previous: None, identifiers, } }; let validator = Validator { globals }; validator.validate(grammar) } struct Validator { globals: ScopeChain<'static>, } #[derive(Copy, Clone, Debug)] enum Def { Terminal, Nonterminal(usize), // argument is the number of macro arguments MacroArg, } #[derive(Debug)] struct ScopeChain<'scope> { previous: Option<&'scope ScopeChain<'scope>>, identifiers: Map, } impl Def { fn description(&self) -> &'static str { match *self { Def::Terminal => "terminal", Def::Nonterminal(0) => "nonterminal", Def::Nonterminal(_) => "macro", Def::MacroArg => "macro argument", } } } impl Validator { fn validate(&self, grammar: &mut Grammar) -> NormResult<()> { for item in &mut grammar.items { match *item { GrammarItem::Use(..) => {} GrammarItem::MatchToken(..) => {} GrammarItem::InternToken(..) => {} GrammarItem::ExternToken(..) => {} GrammarItem::Nonterminal(ref mut data) => { let identifiers = self.validate_macro_args(data.span, &data.args)?; let locals = ScopeChain { previous: Some(&self.globals), identifiers, }; for alternative in &mut data.alternatives { self.validate_alternative(&locals, alternative)?; } } } } Ok(()) } fn validate_macro_args( &self, span: Span, args: &[NonterminalString], ) -> NormResult> { for (index, arg) in args.iter().enumerate() { if args[..index].contains(&arg) { return_err!( span, "multiple macro arguments declared with the name `{}`", arg ); } } Ok(args .iter() .map(|nt| (nt.0.clone(), Def::MacroArg)) .collect()) } fn validate_alternative( &self, scope: &ScopeChain, alternative: &mut Alternative, ) -> NormResult<()> { if let Some(ref condition) = alternative.condition { let def = self.validate_id(scope, condition.span, &condition.lhs.0)?; match def { Def::MacroArg => { /* OK */ } _ => { return_err!( condition.span, "only macro arguments can be used in conditions, \ not {}s like `{}`", def.description(), condition.lhs ); } } } self.validate_expr(scope, &mut alternative.expr)?; Ok(()) } fn validate_expr(&self, scope: &ScopeChain, expr: &mut ExprSymbol) -> NormResult<()> { for symbol in &mut expr.symbols { self.validate_symbol(scope, symbol)?; } Ok(()) } fn validate_symbol(&self, scope: &ScopeChain, symbol: &mut Symbol) -> NormResult<()> { match symbol.kind { SymbolKind::Expr(ref mut expr) => { self.validate_expr(scope, expr)?; } SymbolKind::AmbiguousId(_) => { self.rewrite_ambiguous_id(scope, symbol)?; } SymbolKind::Terminal(_) => { /* see postvalidate! */ } SymbolKind::Nonterminal(ref id) => { // in normal operation, the parser never produces Nonterminal(_) entries, // but during testing we do produce nonterminal entries let def = self.validate_id(scope, symbol.span, &id.0)?; match def { Def::Nonterminal(0) | Def::MacroArg => { // OK } Def::Terminal | Def::Nonterminal(_) => { return_err!( symbol.span, "`{}` is a {}, not a nonterminal", def.description(), id ); } } } SymbolKind::Macro(ref mut msym) => { debug_assert!(!msym.args.is_empty()); let def = self.validate_id(scope, symbol.span, &msym.name.0)?; match def { Def::Nonterminal(0) | Def::Terminal | Def::MacroArg => return_err!( symbol.span, "`{}` is a {}, not a macro", msym.name, def.description() ), Def::Nonterminal(arity) => { if arity != msym.args.len() { return_err!( symbol.span, "wrong number of arguments to `{}`: \ expected {}, found {}", msym.name, arity, msym.args.len() ); } } } for arg in &mut msym.args { self.validate_symbol(scope, arg)?; } } SymbolKind::Repeat(ref mut repeat) => { self.validate_symbol(scope, &mut repeat.symbol)?; } SymbolKind::Choose(ref mut sym) | SymbolKind::Name(_, ref mut sym) => { self.validate_symbol(scope, sym)?; } SymbolKind::Lookahead | SymbolKind::Lookbehind | SymbolKind::Error => {} } Ok(()) } fn rewrite_ambiguous_id(&self, scope: &ScopeChain, symbol: &mut Symbol) -> NormResult<()> { let id = if let SymbolKind::AmbiguousId(ref name) = symbol.kind { name.clone() } else { panic!("Should never happen."); }; symbol.kind = match self.validate_id(scope, symbol.span, &id)? { Def::MacroArg | Def::Nonterminal(0) => SymbolKind::Nonterminal(NonterminalString(id)), Def::Terminal => SymbolKind::Terminal(TerminalString::Bare(id)), Def::Nonterminal(_) => return_err!(symbol.span, "`{}` is a macro", id), }; Ok(()) } fn validate_id(&self, scope: &ScopeChain, span: Span, id: &Atom) -> NormResult { match scope.def(id) { Some(def) => Ok(def), None => return_err!(span, "no definition found for `{}`", id), } } } impl<'scope> ScopeChain<'scope> { fn def(&self, id: &Atom) -> Option { self.identifiers .get(id) .cloned() .or_else(|| self.previous.and_then(|s| s.def(id))) } } lalrpop-0.17.2/src/normalize/resolve/test.rs000064400000000000000000000043721341573332000172420ustar0000000000000000use grammar::parse_tree::Span; use parser; use regex::Regex; fn check_err(expected_err: &str, grammar: &str) { let expected_err = Regex::new(expected_err).unwrap(); // the string will have a `>>>` and `<<<` in it, which serve to // indicate the span where an error is expected. let start_index = grammar.find(">>>").unwrap(); let grammar = grammar.replace(">>>", ""); // remove the `>>>` marker let end_index = grammar.rfind("<<<").unwrap(); let grammar = grammar.replace("<<<", ""); assert!(start_index <= end_index); let parsed_grammar = parser::parse_grammar(&grammar).unwrap(); match super::resolve(parsed_grammar) { Ok(_) => { panic!("expected error for grammar"); } Err(err) => { assert_eq!(err.span, Span(start_index, end_index)); assert!( expected_err.is_match(&err.message), "unexpected error text `{}`, did not match `{}`", err.message, expected_err ); } } } #[test] fn unknown_nonterminal() { check_err("no definition found for `Y`", r#"grammar; X = X >>>Y<<<;"#); } #[test] fn unknown_nonterminal_in_macro_arg() { check_err( "no definition found for `Y`", r#"grammar; X = X Id<>>>Y<<<>; Id = T;"#, ); } #[test] fn unknown_nonterminal_in_repeat_question() { check_err("no definition found for `Y`", r#"grammar; X = >>>Y<< => n.as_num(), "A" <>>>Expr<<<> "B" };"#, ); } #[test] fn double_nonterminal() { check_err( "two nonterminals declared with the name `A`", r#"grammar; A = "Foo"; >>>A<<< = "Bar";"#, ); } #[test] fn repeated_macro_arg() { check_err( "multiple macro arguments declared with the name `Y`", r#"grammar; >>>X<<< = "foo";"#, ); } #[test] fn overlapping_terminal_and_nonterminal() { check_err( "terminal and nonterminal both declared with the name `A`", r#"grammar; A = "Foo"; extern { enum Foo { >>>A => Foo::A(..) <<<} }"#, ); } lalrpop-0.17.2/src/normalize/token_check/mod.rs000064400000000000000000000362621346406170700176520ustar0000000000000000//! If an extern token is provided, then this pass validates that //! terminal IDs have conversions. Otherwise, it generates a //! tokenizer. This can only be done after macro expansion because //! some macro arguments never make it into an actual production and //! are only used in `if` conditions; we use string literals for //! those, but they do not have to have a defined conversion. use super::{NormError, NormResult}; use collections::{Map, Set}; use grammar::consts::*; use grammar::parse_tree::*; use lexer::dfa::{self, DFAConstructionError, Precedence}; use lexer::nfa::NFAConstructionError::*; use lexer::re; use string_cache::DefaultAtom as Atom; #[cfg(test)] mod test; pub fn validate(mut grammar: Grammar) -> NormResult { let mode = { let mode = if let Some(enum_token) = grammar.enum_token() { assert!( grammar.match_token().is_none(), "validator permitted both an extern/match section" ); TokenMode::Extern { conversions: enum_token .conversions .iter() .map(|conversion| conversion.from.clone()) .collect(), } } else { TokenMode::Internal { match_block: MatchBlock::new(grammar.match_token())?, } }; let mut validator = Validator { grammar: &grammar, mode, }; validator.validate()?; validator.mode }; match mode { TokenMode::Extern { .. } => { // If using an external tokenizer, we're all done at this point. } TokenMode::Internal { match_block } => { // Otherwise, construct the `InternToken` item. construct(&mut grammar, match_block)?; } } Ok(grammar) } /////////////////////////////////////////////////////////////////////////// // Validation phase -- this phase walks the grammar and visits all // terminals. If using an external set of tokens, it checks that all // terminals have a defined conversion to some pattern. Otherwise, // it collects all terminals into the `all_literals` set for later use. struct Validator<'grammar> { grammar: &'grammar Grammar, mode: TokenMode, } enum TokenMode { /// If there is an `extern { ... }` section that defines /// conversions of the form `TERMINAL => PATTERN`, then this is a /// set of those terminals. These are the only terminals that the /// user should be using. Extern { conversions: Set }, /// Otherwise, we are synthesizing the tokenizer. In that case, /// `match_block` summarizes the data from the `match { ... }` /// section, if any. If there was no `match` section, or the /// section contains a wildcard, the user can also use additional /// terminals in the grammar. Internal { match_block: MatchBlock }, } /// Data summarizing the `match { }` block, along with any literals we /// scraped up. #[derive(Default)] struct MatchBlock { /// This map stores the `match { }` entries. If `match_catch_all` /// is true, then we will grow this set with "identity mappings" /// for new literals that we find. match_entries: Vec, /// The names of all terminals the user can legally type. If /// `match_catch_all` is true, then if we encounter additional /// terminal literals in the grammar, we will add them to this /// set. match_user_names: Set, /// For each terminal literal that we have to match, the span /// where it appeared in user's source. This can either be in the /// `match { }` section or else in the grammar somewhere (if added /// due to a catch-all, or there is no match section). spans: Map, /// True if we should permit unrecognized literals to be used. catch_all: bool, } impl MatchBlock { /// Creates a `MatchBlock` by reading the data out of the `match { /// ... }` block that the user provided (if any). fn new(opt_match_token: Option<&MatchToken>) -> NormResult { let mut match_block = Self::default(); if let Some(match_token) = opt_match_token { for (idx, mc) in match_token.contents.iter().enumerate() { let precedence = match_token.contents.len() - idx; for item in &mc.items { match *item { MatchItem::Unmapped(ref sym, span) => { match_block.add_match_entry( precedence, sym.clone(), TerminalString::Literal(sym.clone()), span, )?; } MatchItem::Mapped(ref sym, ref user, span) => { match_block.add_match_entry( precedence, sym.clone(), user.clone(), span, )?; } MatchItem::CatchAll(_) => { match_block.catch_all = true; } } } } } else { // no match block is equivalent to `match { _ }` match_block.catch_all = true; } Ok(match_block) } fn add_match_entry( &mut self, match_group_precedence: usize, sym: TerminalLiteral, user_name: TerminalString, span: Span, ) -> NormResult<()> { if let Some(_old_span) = self.spans.insert(sym.clone(), span) { return_err!(span, "multiple match entries for `{}`", sym); } // NB: It's legal for multiple regex to produce same terminal. self.match_user_names.insert(user_name.clone()); self.match_entries.push(MatchEntry { precedence: match_group_precedence * 2 + sym.base_precedence(), match_literal: sym, user_name, }); Ok(()) } fn add_literal_from_grammar(&mut self, sym: TerminalLiteral, span: Span) -> NormResult<()> { // Already saw this literal, maybe in a match entry, maybe in the grammar. if self .match_user_names .contains(&TerminalString::Literal(sym.clone())) { return Ok(()); } if !self.catch_all { return_err!( span, "terminal `{}` does not have a match mapping defined for it", sym ); } self.match_user_names .insert(TerminalString::Literal(sym.clone())); self.match_entries.push(MatchEntry { precedence: sym.base_precedence(), match_literal: sym.clone(), user_name: TerminalString::Literal(sym.clone()), }); self.spans.insert(sym, span); Ok(()) } } impl<'grammar> Validator<'grammar> { fn validate(&mut self) -> NormResult<()> { for item in &self.grammar.items { match *item { GrammarItem::Use(..) => {} GrammarItem::MatchToken(..) => {} GrammarItem::ExternToken(_) => {} GrammarItem::InternToken(_) => {} GrammarItem::Nonterminal(ref data) => { for alternative in &data.alternatives { self.validate_alternative(alternative)?; } } } } Ok(()) } fn validate_alternative(&mut self, alternative: &Alternative) -> NormResult<()> { assert!(alternative.condition.is_none()); // macro expansion should have removed these self.validate_expr(&alternative.expr)?; Ok(()) } fn validate_expr(&mut self, expr: &ExprSymbol) -> NormResult<()> { for symbol in &expr.symbols { self.validate_symbol(symbol)?; } Ok(()) } fn validate_symbol(&mut self, symbol: &Symbol) -> NormResult<()> { match symbol.kind { SymbolKind::Expr(ref expr) => { self.validate_expr(expr)?; } SymbolKind::Terminal(ref term) => { self.validate_terminal(symbol.span, term)?; } SymbolKind::Nonterminal(_) => {} SymbolKind::Repeat(ref repeat) => { self.validate_symbol(&repeat.symbol)?; } SymbolKind::Choose(ref sym) | SymbolKind::Name(_, ref sym) => { self.validate_symbol(sym)?; } SymbolKind::Lookahead | SymbolKind::Lookbehind | SymbolKind::Error => {} SymbolKind::AmbiguousId(ref id) => { panic!("ambiguous id `{}` encountered after name resolution", id) } SymbolKind::Macro(..) => { panic!("macro not removed: {:?}", symbol); } } Ok(()) } fn validate_terminal(&mut self, span: Span, term: &TerminalString) -> NormResult<()> { match self.mode { // If there is an extern token definition, validate that // this terminal has a defined conversion. TokenMode::Extern { ref conversions } => { if !conversions.contains(term) { return_err!( span, "terminal `{}` does not have a pattern defined for it", term ); } } // If there is no extern token definition, then collect // the terminal literals ("class", r"[a-z]+") into a set. TokenMode::Internal { ref mut match_block, } => { match *term { TerminalString::Bare(_) => assert!( match_block.match_user_names.contains(term), "bare terminal without match entry: {}", term ), TerminalString::Literal(ref l) => { match_block.add_literal_from_grammar(l.clone(), span)? } // Error is a builtin terminal that always exists TerminalString::Error => (), } } } Ok(()) } } /////////////////////////////////////////////////////////////////////////// // Construction phase -- if we are constructing a tokenizer, this // phase builds up an internal token DFA. fn construct(grammar: &mut Grammar, match_block: MatchBlock) -> NormResult<()> { let MatchBlock { mut match_entries, spans, .. } = match_block; // Sort match entries by order of increasing precedence. match_entries.sort(); // Build up two vectors, one of parsed regular expressions and // one of precedences, that are parallel with `literals`. let mut regexs = Vec::with_capacity(match_entries.len()); let mut precedences = Vec::with_capacity(match_entries.len()); { for match_entry in &match_entries { precedences.push(Precedence(match_entry.precedence)); match match_entry.match_literal { TerminalLiteral::Quoted(ref s) => { regexs.push(re::parse_literal(&s)); } TerminalLiteral::Regex(ref s) => { match re::parse_regex(&s) { Ok(regex) => regexs.push(regex), Err(error) => { let literal_span = spans[&match_entry.match_literal]; // FIXME -- take offset into account for // span; this requires knowing how many # // the user used, which we do not track return_err!(literal_span, "invalid regular expression: {}", error); } } } } } Ok(()) }?; let dfa = match dfa::build_dfa(®exs, &precedences) { Ok(dfa) => dfa, Err(DFAConstructionError::NFAConstructionError { index, error }) => { let feature = match error { NamedCaptures => r#"named captures (`(?P...)`)"#, NonGreedy => r#""non-greedy" repetitions (`*?` or `+?`)"#, WordBoundary => r#"word boundaries (`\b` or `\B`)"#, LineBoundary => r#"line boundaries (`^` or `$`)"#, TextBoundary => r#"text boundaries (`^` or `$`)"#, ByteRegex => r#"byte-based matches"#, }; let literal = &match_entries[index.index()].match_literal; return_err!( spans[literal], "{} are not supported in regular expressions", feature ) } Err(DFAConstructionError::Ambiguity { match0, match1 }) => { let literal0 = &match_entries[match0.index()].match_literal; let literal1 = &match_entries[match1.index()].match_literal; // FIXME(#88) -- it'd be nice to give an example here return_err!( spans[literal0], "ambiguity detected between the terminal `{}` and the terminal `{}`", literal0, literal1 ) } }; grammar .items .push(GrammarItem::InternToken(InternToken { match_entries, dfa })); // we need to inject a `'input` lifetime and `input: &'input str` parameter as well: let input_lifetime = Lifetime::input(); for parameter in &grammar.type_parameters { match parameter { TypeParameter::Lifetime(i) if *i == input_lifetime => { return_err!( grammar.span, "since there is no external token enum specified, \ the `'input` lifetime is implicit and cannot be declared" ); } _ => {} } } let input_parameter = Atom::from(INPUT_PARAMETER); for parameter in &grammar.parameters { if parameter.name == input_parameter { return_err!( grammar.span, "since there is no external token enum specified, \ the `input` parameter is implicit and cannot be declared" ); } } grammar .type_parameters .insert(0, TypeParameter::Lifetime(input_lifetime.clone())); let parameter = Parameter { name: input_parameter, ty: TypeRef::Ref { lifetime: Some(input_lifetime), mutable: false, referent: Box::new(TypeRef::Id(Atom::from("str"))), }, }; grammar.parameters.push(parameter); Ok(()) } lalrpop-0.17.2/src/normalize/token_check/test.rs000064400000000000000000000145661341573332000200460ustar0000000000000000use grammar::parse_tree::Grammar; use lexer::dfa::interpret; use normalize::resolve::resolve; use normalize::NormResult; use parser; use test_util; fn validate_grammar(grammar: &str) -> NormResult { let parsed_grammar = parser::parse_grammar(&grammar).expect("parse grammar"); let parsed_grammar = resolve(parsed_grammar).expect("resolve"); super::validate(parsed_grammar) } fn check_err(expected_err: &str, grammar: &str, span: &str) { let err = validate_grammar(&grammar).unwrap_err(); test_util::check_norm_err(expected_err, span, err); } fn check_intern_token(grammar: &str, expected_tokens: Vec<(&'static str, &'static str)>) { let parsed_grammar = validate_grammar(&grammar).expect("validate"); let intern_token = parsed_grammar.intern_token().expect("intern_token"); println!("intern_token: {:?}", intern_token); for (input, expected_user_name) in expected_tokens { let actual_user_name = interpret::interpret(&intern_token.dfa, input).map(|(index, text)| { let user_name = &intern_token.match_entries[index.index()].user_name; (user_name.clone(), text) }); let actual_user_name = format!("{:?}", actual_user_name); if expected_user_name != actual_user_name { panic!( "input `{}` matched `{}` but we expected `{}`", input, actual_user_name, expected_user_name ); } } } #[test] fn unknown_terminal() { check_err( r#"terminal `"\+"` does not have a pattern defined for it"#, r#"grammar; extern { enum Term { } } X = X "+";"#, r#" ~~~ "#, ); } #[test] fn unknown_id_terminal() { check_err( r#"terminal `"foo"` does not have a pattern defined for it"#, r#"grammar; extern { enum Term { } } X = X "foo";"#, r#" ~~~~~ "#, ); } #[test] fn tick_input_lifetime_already_declared() { check_err( r#".*the `'input` lifetime is implicit and cannot be declared"#, r#"grammar<'input>; X = X "foo";"#, r#"~~~~~~~ "#, ); } #[test] fn input_parameter_already_declared() { check_err( r#".*the `input` parameter is implicit and cannot be declared"#, r#"grammar(input:u32); X = X "foo";"#, r#"~~~~~~~ "#, ); } #[test] fn invalid_regular_expression_unterminated_group() { check_err( r#"unclosed group"#, r#"grammar; X = X r"(123";"#, r#" ~~~~~~~ "#, ); } #[test] fn quoted_literals() { check_intern_token( r#"grammar; X = X "+" "-" "foo" "(" ")";"#, vec![ ("+", r#"Some(("+", "+"))"#), ("-", r#"Some(("-", "-"))"#), ("(", r#"Some(("(", "("))"#), (")", r#"Some((")", ")"))"#), ("foo", r#"Some(("foo", "foo"))"#), ("<", r#"None"#), ], ); } #[test] fn regex_literals() { check_intern_token( r#"grammar; X = X r"[a-z]+" r"[0-9]+";"#, vec![ ("a", r##"Some((r#"[a-z]+"#, "a"))"##), ("def", r##"Some((r#"[a-z]+"#, "def"))"##), ("1", r##"Some((r#"[0-9]+"#, "1"))"##), ("9123456", r##"Some((r#"[0-9]+"#, "9123456"))"##), ], ); } /// Basic test for match mappings. #[test] fn match_mappings() { check_intern_token( r#"grammar; match { r"(?i)begin" => "BEGIN" } else { "abc" => ALPHA } X = "BEGIN" ALPHA;"#, vec![ ("BEGIN", r##"Some(("BEGIN", "BEGIN"))"##), ("begin", r##"Some(("BEGIN", "begin"))"##), ("abc", r#"Some((ALPHA, "abc"))"#), ], ); } /// Match mappings, exercising precedence. Here the ID regex *would* /// be ambiguous with the begin regex. #[test] fn match_precedence() { check_intern_token( r#"grammar; match { r"(?i)begin" => "BEGIN" } else { r"\w+" => ID } X = ();"#, vec![ ("BEGIN", r##"Some(("BEGIN", "BEGIN"))"##), ("begin", r##"Some(("BEGIN", "begin"))"##), ("abc", r#"Some((ID, "abc"))"#), ], ); } /// Test that, without a `catch-all`, using unrecognized literals is an error. #[test] fn invalid_match_literal() { check_err( r#"terminal `"foo"` does not have a match mapping defined for it"#, r#"grammar; match { r"(?i)begin" => "BEGIN" } X = "foo";"#, r#" ~~~~~ "#, ); } /// Test that, without a `catch-all`, using unrecognized literals is an error. #[test] fn invalid_match_regex_literal() { check_err( r##"terminal `r#"foo"#` does not have a match mapping defined for it"##, r#"grammar; match { r"(?i)begin" => "BEGIN" } X = r"foo";"#, r#" ~~~~~~ "#, ); } /// Test that, with a catch-all, the previous two examples work. #[test] fn match_catch_all() { let grammar = r#"grammar; match { r"(?i)begin" => "BEGIN", _ } X = { "foo", r"foo" };"#; assert!(validate_grammar(&grammar).is_ok()) } #[test] fn complex_match() { let grammar = r##" grammar; match { "abc" => "ABC", r"(?i)begin" => BEGIN } pub Query: String = { "ABC" BEGIN => String::from("Success") }; "##; assert!(validate_grammar(&grammar).is_ok()) } /// Test that overlapping regular expressions are still forbidden within one level /// of a match declaration. #[test] fn ambiguity_within_match() { check_err( r##"ambiguity detected between the terminal `r#"b"#` and the terminal `r#"\(\?i\)b"#`"##, r#"grammar; match { r"(?i)b" => "B", r"b" => "b" }"#, r#" ~~~~~~~~~~~~ "#, ); } /// Test that using the **exact same regular expression** twice is /// forbidden, even across multiple levels of the match expression. /// No good reason to do that. #[test] fn same_literal_twice() { check_err( r##"multiple match entries for `r#"\(\?i\)b"#`"##, r#"grammar; match { r"(?i)b" => "B" } else { r"(?i)b" => "b" }"#, r#" ~~~~~~~~~~~~~~~~ "#, ); } lalrpop-0.17.2/src/normalize/tyinfer/mod.rs000064400000000000000000000330161352730432300170410ustar0000000000000000use super::norm_util::{self, AlternativeAction, Symbols}; use super::{NormError, NormResult}; use grammar::consts::{ERROR, LOCATION}; use grammar::parse_tree::{ ActionKind, Alternative, Grammar, GrammarItem, Lifetime, NonterminalData, NonterminalString, Path, Span, SymbolKind, TypeParameter, TypeRef, }; use grammar::repr::{NominalTypeRepr, TypeRepr, Types}; use std::collections::{HashMap, HashSet}; use string_cache::DefaultAtom as Atom; #[cfg(test)] mod test; pub fn infer_types(grammar: &Grammar) -> NormResult { let inferencer = TypeInferencer::new(&grammar)?; inferencer.infer_types() } struct TypeInferencer<'grammar> { stack: Vec, nonterminals: HashMap>, types: Types, type_parameters: HashSet, } #[derive(Copy, Clone)] struct NT<'grammar> { span: Span, type_decl: &'grammar Option, alternatives: &'grammar Vec, } impl<'grammar> TypeInferencer<'grammar> { fn new(grammar: &'grammar Grammar) -> NormResult> { let types = TypeInferencer::make_types(grammar); let nonterminals = grammar .items .iter() .filter_map(GrammarItem::as_nonterminal) .map(|data| { assert!(!data.is_macro_def()); // normalized away by now (data.name.clone(), NT::new(data)) }) .collect(); let type_parameters = grammar .type_parameters .iter() .filter_map(|p| match *p { TypeParameter::Lifetime(_) => None, TypeParameter::Id(ref ty) => Some(ty.clone()), }) .collect(); Ok(TypeInferencer { stack: vec![], nonterminals, types, type_parameters, }) } fn make_types(grammar: &Grammar) -> Types { let opt_extern_token = grammar.extern_token(); // Determine error type (if any). let error_type = opt_extern_token.and_then(|extern_token| { extern_token .associated_type(Atom::from(ERROR)) .map(|tr| tr.type_ref.type_repr()) }); // Determine location type and enum type. If using an internal // token, that's specified by us, not user. if let Some(intern_token) = grammar.intern_token() { let loc_type = // usize TypeRepr::usize(); let input_str = // &'input str TypeRepr::Ref { lifetime: Some(Lifetime::input()), mutable: false, referent: Box::new(TypeRepr::str()) }; let enum_type = // Token<'input> TypeRepr::Nominal(NominalTypeRepr { path: Path { absolute: false, ids: vec![Atom::from("Token")], }, types: vec![TypeRepr::Lifetime(Lifetime::input())] }); let mut types = Types::new(&grammar.prefix, Some(loc_type), error_type, enum_type); for match_entry in &intern_token.match_entries { types.add_term_type(match_entry.user_name.clone(), input_str.clone()); } types } else { let extern_token = opt_extern_token.unwrap(); let loc_type = extern_token .associated_type(Atom::from(LOCATION)) .map(|tr| tr.type_ref.type_repr()); let enum_type = extern_token .enum_token .as_ref() .unwrap() .type_name .type_repr(); let mut types = Types::new(&grammar.prefix, loc_type, error_type, enum_type); // For each defined conversion, figure out the type of the // terminal and enter it into `types` by hand if it is not the // default. For terminals with custom types, the user should // have one or more bindings in the pattern -- if more than // one, make a tuple. // // e.g. "(" => Lparen(..) ==> no custom type // "Num" => Num() ==> custom type is u32 // "Fraction" => Real(,) ==> custom type is (u32, u32) for conversion in grammar .enum_token() .into_iter() .flat_map(|et| &et.conversions) { let mut tys = Vec::new(); conversion .to .for_each_binding(&mut |ty| tys.push(ty.type_repr())); if tys.is_empty() { continue; } let ty = maybe_tuple(tys); types.add_term_type(conversion.from.clone(), ty); } types } } fn infer_types(mut self) -> NormResult { let ids: Vec = self.nonterminals.iter().map(|(id, _)| id.clone()).collect(); for id in ids { self.nonterminal_type(&id)?; debug_assert!(self.types.lookup_nonterminal_type(&id).is_some()); } Ok(self.types) } fn nonterminal_type(&mut self, id: &NonterminalString) -> NormResult { if let Some(repr) = self.types.lookup_nonterminal_type(id) { return Ok(repr.clone()); } let nt = self.nonterminals[&id]; if self.stack.contains(&id) { return_err!( nt.span, "cannot infer type of `{}` because it references itself", id ); } let ty = self.push(id, |this| { if let Some(ref type_decl) = nt.type_decl { return this.type_ref(type_decl); } // Try to compute the types of all alternatives; note that // some may result in an error. Don't report these errors // (yet). let mut alternative_types = vec![]; let mut alternative_errors = vec![]; for alt in nt.alternatives.iter() { match this.alternative_type(alt) { Ok(t) => alternative_types.push(t), Err(e) => alternative_errors.push(e), } } // if it never succeeded, report first error if alternative_types.is_empty() { match alternative_errors.into_iter().next() { Some(err) => { return Err(err); } None => { // if nothing succeeded, and nothing errored, // must have been nothing to start with return_err!( nt.span, "nonterminal `{}` has no alternatives and hence parse cannot succeed", id ); } } } // otherwise, check that all the cases where we had success agree for ((ty, alt), i) in alternative_types[1..] .iter() .zip(&nt.alternatives[1..]) .zip(1..) { if &alternative_types[0] != ty { return_err!( alt.span, "type of alternative #{} is `{}`, \ but type of first alternative is `{}`", i + 1, ty, alternative_types[0] ); } } // and use that type Ok(alternative_types.pop().unwrap()) })?; self.types.add_type(id.clone(), ty.clone()); Ok(ty) } fn push(&mut self, id: &NonterminalString, f: F) -> NormResult where F: FnOnce(&mut TypeInferencer) -> NormResult, { self.stack.push(id.clone()); let r = f(self); assert_eq!(self.stack.pop().unwrap(), *id); r } fn type_ref(&mut self, type_ref: &TypeRef) -> NormResult { match *type_ref { TypeRef::Tuple(ref types) => { let types = types .iter() .map(|t| self.type_ref(t)) .collect::>()?; Ok(TypeRepr::Tuple(types)) } TypeRef::Nominal { ref path, ref types, } => { if path.ids.len() == 2 && self.type_parameters.contains(&path.ids[0]) { return Ok(TypeRepr::Associated { type_parameter: path.ids[0].clone(), id: path.ids[1].clone(), }); } let types = types .iter() .map(|t| self.type_ref(t)) .collect::>()?; Ok(TypeRepr::Nominal(NominalTypeRepr { path: path.clone(), types, })) } TypeRef::Lifetime(ref id) => Ok(TypeRepr::Lifetime(id.clone())), TypeRef::Id(ref id) => Ok(TypeRepr::Nominal(NominalTypeRepr { path: Path::from_id(id.clone()), types: vec![], })), TypeRef::Ref { ref lifetime, mutable, ref referent, } => Ok(TypeRepr::Ref { lifetime: lifetime.clone(), mutable, referent: Box::new(self.type_ref(referent)?), }), TypeRef::OfSymbol(ref symbol) => self.symbol_type(symbol), TypeRef::TraitObject { ref path, ref types, } => { let types = types .iter() .map(|t| self.type_ref(t)) .collect::>()?; Ok(TypeRepr::TraitObject(NominalTypeRepr { path: path.clone(), types, })) } TypeRef::Fn { ref forall, ref path, ref parameters, ref ret, } => Ok(TypeRepr::Fn { forall: forall.clone(), path: path.clone(), parameters: parameters .iter() .map(|t| self.type_ref(t)) .collect::>()?, ret: match ret { Some(ret) => Some(self.type_ref(ret).map(Box::new)?), None => None, }, }), } } fn alternative_type(&mut self, alt: &Alternative) -> NormResult { match norm_util::analyze_action(alt) { AlternativeAction::User(&ActionKind::User(_)) | AlternativeAction::User(&ActionKind::Fallible(_)) => { return_err!( alt.span, "cannot infer types if there is custom action code" ); } AlternativeAction::User(&ActionKind::Lookahead) | AlternativeAction::User(&ActionKind::Lookbehind) => { Ok(self.types.opt_terminal_loc_type().unwrap().clone()) } AlternativeAction::Default(Symbols::Named(ref syms)) => { return_err!( alt.span, "cannot infer types in the presence of named symbols like `{}:{}`", syms[0].1, syms[0].2 ); } AlternativeAction::Default(Symbols::Anon(syms)) => { let symbol_types: Vec = syms .iter() .map(|&(_, sym)| self.symbol_type(&sym.kind)) .collect::>()?; Ok(maybe_tuple(symbol_types)) } } } fn symbol_type(&mut self, symbol: &SymbolKind) -> NormResult { match *symbol { SymbolKind::Terminal(ref id) => Ok(self.types.terminal_type(id).clone()), SymbolKind::Nonterminal(ref id) => self.nonterminal_type(id), SymbolKind::Choose(ref s) => self.symbol_type(&s.kind), SymbolKind::Name(_, ref s) => self.symbol_type(&s.kind), SymbolKind::Error => Ok(self.types.error_recovery_type().clone()), SymbolKind::Repeat(..) | SymbolKind::Expr(..) | SymbolKind::Macro(..) | SymbolKind::AmbiguousId(..) | SymbolKind::Lookahead | SymbolKind::Lookbehind => { unreachable!("symbol `{:?}` should have been expanded away", symbol) } } } } impl<'grammar> NT<'grammar> { fn new(data: &'grammar NonterminalData) -> NT<'grammar> { NT { span: data.span, type_decl: &data.type_decl, alternatives: &data.alternatives, } } } fn maybe_tuple(v: Vec) -> TypeRepr { if v.len() == 1 { v.into_iter().next().unwrap() } else { TypeRepr::Tuple(v) } } lalrpop-0.17.2/src/normalize/tyinfer/test.rs000064400000000000000000000113071341573332000172370ustar0000000000000000use grammar::parse_tree::NonterminalString; use grammar::repr::TypeRepr; use normalize::macro_expand::expand_macros; use normalize::token_check; use normalize::tyinfer::infer_types; use parser; use string_cache::DefaultAtom as Atom; fn type_repr(s: &str) -> TypeRepr { let type_ref = parser::parse_type_ref(s).unwrap(); return type_ref.type_repr(); } fn compare(g1: &str, expected: Vec<(&'static str, &'static str)>) { let grammar = parser::parse_grammar(g1).unwrap(); let grammar = expand_macros(grammar).unwrap(); let grammar = token_check::validate(grammar).unwrap(); let types = infer_types(&grammar).unwrap(); println!("types table: {:?}", types); for (nt_id, nt_type) in expected { let id = NonterminalString(Atom::from(nt_id)); let ty = type_repr(nt_type); println!("expected type of {:?} is {:?}", id, ty); assert_eq!(types.nonterminal_type(&id), &ty); } } #[test] fn test_pairs_and_tokens() { compare( r#" grammar; extern { enum Tok { "Hi" => Hi(..), "Ho" => Ho(..) } } X = Y Z; Y: Foo = "Hi"; Z = "Ho"; "#, vec![("X", "(Foo, Tok)"), ("Y", "Foo"), ("Z", "Tok")], ) } #[test] fn test_cycle_direct() { let grammar = parser::parse_grammar( r#" grammar; extern { enum Tok { "Hi" => Hi(..), "Ho" => Ho(..) } } X = { X Y, => vec![<>] }; Y = "Hi"; "#, ) .unwrap(); let actual = expand_macros(grammar).unwrap(); assert!(infer_types(&actual).is_err()); } #[test] fn test_cycle_indirect() { let grammar = parser::parse_grammar( r#" grammar; extern { enum Tok { } } A = B; B = C; C = D; D = A; "#, ) .unwrap(); let actual = expand_macros(grammar).unwrap(); assert!(infer_types(&actual).is_err()); } #[test] fn test_macro_expansion() { compare( r#" grammar; extern { enum Tok { "Id" => Id(..) } } Two: (X, X) = X X; Ids = Two<"Id">; "#, vec![("Ids", "(Tok, Tok)"), (r#"Two<"Id">"#, "(Tok, Tok)")], ) } #[test] fn test_macro_expansion_infer() { compare( r#" grammar; extern { enum Tok { "Id" => Id(..) } } Two = X X; Ids = Two<"Id">; "#, vec![("Ids", "(Tok, Tok)"), (r#"Two<"Id">"#, "(Tok, Tok)")], ) } #[test] fn test_type_question() { compare( r#" grammar; extern { enum Tok { "Hi" => Hi(..) } } X = Y?; Y = "Hi"; "#, vec![("X", "::std::option::Option"), ("Y", "Tok")], ) } #[test] fn test_star_plus_question() { compare( r#" grammar; extern { enum Tok { "Hi" => Hi(..) } } A = Z*; X = "Hi"*; Y = "Hi"+; Z = "Hi"?; "#, vec![ ("A", "::std::vec::Vec<::std::option::Option>"), ("X", "::std::vec::Vec"), ("Y", "::std::vec::Vec"), ("Z", "::std::option::Option"), ], ) } #[test] fn test_lookahead() { compare( r#" grammar; extern { type Location = usize; enum Tok { } } A = @L; "#, vec![("A", "usize")], ) } #[test] fn test_spanned_macro() { compare( r#" grammar; extern { type Location = usize; enum Tok { "Foo" => Foo(..) } } A = Spanned<"Foo">; Spanned = { @L T @R }; "#, vec![("A", "(usize, Tok, usize)")], ) } #[test] fn test_action() { compare( r#" grammar; extern { enum Tok { "+" => .., "foo" => .. } } X = { Y, "+" => l + r }; Y: i32 = "foo" => 22; "#, vec![("X", "i32"), ("Y", "i32")], ) } #[test] fn test_inconsistent_action() { let grammar = parser::parse_grammar( r#" grammar; extern { enum Tok { "+" => .., "foo" => .., "bar" => .. } } X = { Y, Z, "+" => l + r }; Y: i32 = "foo" => 22; Z: u32 = "bar" => 22; "#, ) .unwrap(); let actual = expand_macros(grammar).unwrap(); assert!(infer_types(&actual).is_err()); } #[test] fn custom_token() { compare( r#" grammar; extern { enum Tok { N => N() } } A = N; "#, vec![("A", "u32")], ) } #[test] fn intern_token() { compare( r#" grammar; Z = @L "Ho" @R; "#, vec![("Z", "(usize, &'input str, usize)")], ) } #[test] fn error() { compare( r#" grammar; Z = !; "#, vec![( "Z", "__lalrpop_util::ErrorRecovery, &'static str>", )], ) } lalrpop-0.17.2/src/parser/lrgrammar.lalrpop000064400000000000000000000342511352730432300171110ustar0000000000000000use string_cache::DefaultAtom as Atom; use grammar::parse_tree::*; use grammar::pattern::*; use std::iter::once; use tok::{self, Tok}; use util::strip; use lalrpop_util::ParseError; use super::Top; grammar<'input>(text: &'input str); pub Top: Top = { "StartGrammar" => Top::Grammar(<>), "StartPattern" => Top::Pattern(<>), "StartMatchMapping" => Top::MatchMapping(<>), "StartTypeRef" => Top::TypeRef(<>), "StartGrammarWhereClauses" => Top::GrammarWhereClauses(<>), }; Grammar: Grammar = "grammar" ";" => { Grammar { prefix: format!("__"), // adjusted by `parse_grammar` span: Span(lo, hi), type_parameters: tps.unwrap_or(vec![]), parameters: parameters.unwrap_or(vec![]), where_clauses: where_clauses.unwrap_or(vec![]), items: uses.into_iter().chain(items).collect(), annotations, module_attributes } }; GrammarTypeParameters: Vec = "<" > ">"; TypeParameter: TypeParameter = { => TypeParameter::Lifetime(l), => TypeParameter::Id(l) }; GrammarWhereClauses: Vec> = "where" >; GrammarWhereClause: WhereClause = { ":" > => WhereClause::Lifetime { lifetime: l, bounds }, ":" => WhereClause::Type { forall: f, ty, bounds } }; #[inline] ForAll: Vec = { "for" "<" > ">", () => vec![], }; TypeBounds: Vec> = >; TypeBound: TypeBound = { => TypeBound::Lifetime(l), "(" > ")" " )?> => TypeBound::Fn { forall: f, path: p, parameters: params, ret }, > ">")?> => TypeBound::Trait { forall: f, path: p, parameters: params.unwrap_or(vec![]) } }; TypeBoundParameter: TypeBoundParameter = { => TypeBoundParameter::Lifetime(l), => TypeBoundParameter::TypeParameter(ty), "=" => TypeBoundParameter::Associated(id, ty), }; Plus: Vec = { "+")*> => match e { None => v, Some(e) => { v.push(e); v } } }; GrammarParameters: Vec = "(" > ")"; GrammarParameter: Parameter = ":" => Parameter { name: id, ty }; GrammarItem: GrammarItem = { Use, MatchToken, ExternToken, Nonterminal }; Use: GrammarItem = ";" => GrammarItem::Use(strip(u).to_string()); Visibility: Visibility = { "pub" "(" ")" => Visibility::Pub(Some(p)), "pub" => Visibility::Pub(None), () => Visibility::Priv, }; Nonterminal: GrammarItem = )?> "=" => { GrammarItem::Nonterminal(NonterminalData { visibility: v, span: Span(lo, hi), name: n.0, annotations, args: n.1, type_decl: t, alternatives: a }) }; AnnotationArg: (Atom, String) = "(" "=" ")" => (name, value.into()); Annotation: Annotation = "#" "[" "]" => { Annotation { id_span: Span(lo, hi), id, arg } }; NonterminalName: (NonterminalString, Vec) = { "<" > ">", => (n, vec![]), <"Escape"> => (NonterminalString(Atom::from(<>)), vec![]), }; Alternatives: Vec = { ";" => vec![a], "{" > "}" ";"?, }; Alternative: Alternative = { )?> => { Alternative { span: Span(lo, hi), expr: ExprSymbol { symbols: s }, condition: c, action: a } }, )?> => { Alternative { span: Span(lo, hi), expr: ExprSymbol { symbols: vec![] }, condition: c, action: Some(a) } }, }; Action: ActionKind = { "=>@L" => ActionKind::Lookahead, "=>@R" => ActionKind::Lookbehind, "> => ActionKind::User(strip(c).to_string()), ?"> => ActionKind::Fallible(strip(c).to_string()), }; Cond: Condition = => { Condition { span:Span(lo, hi), lhs:a, rhs:b, op } }; CondOp: ConditionOp = { "==" => ConditionOp::Equals, "!=" => ConditionOp::NotEquals, "~~" => ConditionOp::Match, "!~" => ConditionOp::NotMatch, }; ExprSymbol: ExprSymbol = Symbol* => ExprSymbol { symbols: <> }; Symbol: Symbol = { "<" @L ":" ">" => Symbol::new(Span(lo, hi), SymbolKind::Name(Name::new(m.is_some(), l), Box::new(s))), "<" ">" => Symbol::new(Span(lo, hi), SymbolKind::Choose(Box::new(s))), Symbol0, }; Symbol0: Symbol = { Symbol1, => Symbol::new(Span(lhs.span.0, hi), SymbolKind::Repeat(Box::new(RepeatSymbol { symbol: lhs, op }))), }; RepeatOp: RepeatOp = { "+" => RepeatOp::Plus, "*" => RepeatOp::Star, "?" => RepeatOp::Question, }; Symbol1: Symbol = => Symbol::new(Span(lo, hi), sk); SymbolKind1: SymbolKind = { "<" > ">" => SymbolKind::Macro(MacroSymbol { name, args }), QuotedTerminal => SymbolKind::Terminal(<>), "Id" => SymbolKind::AmbiguousId(Atom::from(<>)), Escape => SymbolKind::Nonterminal(NonterminalString(<>)), "(" ")" => SymbolKind::Expr(<>), "@L" => SymbolKind::Lookahead, "@R" => SymbolKind::Lookbehind, "!" => SymbolKind::Error, }; TypeRef: TypeRef = { "(" > ")" => TypeRef::Tuple(<>), "#" "#" => { TypeRef::OfSymbol(<>.kind) }, "&" => TypeRef::Ref { lifetime: l, mutable: m.is_some(), referent: Box::new(t) }, "<" > ">" => TypeRef::Nominal { <> }, => match p.as_id() { Some(id) => TypeRef::Id(id), None => TypeRef::Nominal { path: p, types: vec![] }, }, "dyn" "<" > ">" => TypeRef::TraitObject { <> }, "dyn" => TypeRef::TraitObject { path, types: vec![] }, "dyn" "(" > ")" " )?> => TypeRef::Fn { forall, path, parameters, ret: ret.map(Box::new) }, }; TypeRefOrLifetime: TypeRef = { TypeRef, Lifetime => TypeRef::Lifetime(<>), }; Path: Path = "::")*> => { Path { absolute: a.is_some(), ids: h.into_iter().chain(once(t)).collect() } }; ExternToken: GrammarItem = { "extern" "{" "}" => { GrammarItem::ExternToken(ExternToken { span: Span(lo, hi), associated_types: a0.into_iter().chain(a1).collect(), enum_token: Some(et), }) }, "extern" "{" "}" => { GrammarItem::ExternToken(ExternToken { span: Span(lo, hi), associated_types: a0, enum_token: None, }) }, }; MatchToken: GrammarItem = => GrammarItem::MatchToken(t); MatchTokenInt: MatchToken = { "else" "{" "}" => t.add(c), "match" "{" "}" => MatchToken::new(c, Span(lo, hi)), }; MatchContents: MatchContents = > => MatchContents { items }; MatchItem: MatchItem = { "_" => MatchItem::CatchAll(Span(lo, hi)), => MatchItem::Unmapped(s, Span(lo, hi)), "> =>? { let to = super::parse_match_mapping(p, start + 2)?; Ok(MatchItem::Mapped(from, to, Span(lo, hi))) } }; MatchSymbol = QuotedLiteral; MatchMapping = Terminal; EnumToken: EnumToken = "enum" "{" > "}" => { EnumToken { type_name: t, type_span: Span(lo, hi), conversions: c, } }; AssociatedType: AssociatedType = "type" "=" ";" => { AssociatedType { type_span: Span(lo, hi), type_name: n, type_ref: t } }; Conversion: Conversion = "> =>? { let pattern = super::parse_pattern(p, start + 2)?; Ok(Conversion { span: Span(lo, hi), from, to: pattern }) }; Pattern: Pattern = => Pattern { span: Span(lo, hi), kind: k }; PatternKind: PatternKind = { "(" > ")" => PatternKind::Enum(<>), "{" ",")*> "}" => PatternKind::Struct(p, a0.into_iter().chain(a1).collect(), false), "{" ",")*> ".." "}" => PatternKind::Struct(p, a0, true), "_" => PatternKind::Underscore, ".." => PatternKind::DotDot, "<" ">" => PatternKind::Choose(<>), "(" > ")" => PatternKind::Tuple(<>), => PatternKind::CharLiteral(Atom::from(c)), => PatternKind::Path(<>), }; FieldPattern: FieldPattern = ":" => { FieldPattern { field_span: Span(lo, hi), field_name: id, pattern: pat } }; MacroId: NonterminalString = => NonterminalString(Atom::from(i)); NotMacroId: NonterminalString = => NonterminalString(Atom::from(i)); Id: Atom = { => Atom::from(i), => Atom::from(i), }; Escape: Atom = => Atom::from(i); Lifetime: Lifetime = => Lifetime(Atom::from(i)); Terminal: TerminalString = { QuotedTerminal, => TerminalString::Bare(Atom::from(i)), }; QuotedTerminal: TerminalString = { QuotedLiteral => TerminalString::Literal(<>), }; QuotedLiteral: TerminalLiteral = { => TerminalLiteral::Quoted(s), => TerminalLiteral::Regex(s), }; StringLiteral: Atom = =>? { let text = tok::apply_string_escapes(s, lo + 1) .map_err(|e| ParseError::User { error: e })?; Ok(Atom::from(text)) }; RegexLiteral: Atom = => Atom::from(s); Comma: Vec = ",")*> => v0.into_iter().chain(e1).collect(); ShebangAttribute: String = => s.to_string(); extern { type Location = usize; type Error = tok::Error; enum Tok<'input> { "enum" => Tok::Enum, "extern" => Tok::Extern, "grammar" => Tok::Grammar, "match" => Tok::Match, "else" => Tok::Else, "if" => Tok::If, "mut" => Tok::Mut, "pub" => Tok::Pub, "type" => Tok::Type, "where" => Tok::Where, "for" => Tok::For, "!" => Tok::Bang, "use" => Tok::Use(<&'input str>), "dyn" => Tok::Dyn, "Escape" => Tok::Escape(<&'input str>), "Id" => Tok::Id(<&'input str>), "MacroId" => Tok::MacroId(<&'input str>), "Lifetime" => Tok::Lifetime(<&'input str>), "StringLiteral" => Tok::StringLiteral(<&'input str>), "CharLiteral" => Tok::CharLiteral(<&'input str>), "RegexLiteral" => Tok::RegexLiteral(<&'input str>), "&" => Tok::Ampersand, "!=" => Tok::BangEquals, "!~" => Tok::BangTilde, ":" => Tok::Colon, "::" => Tok::ColonColon, "," => Tok::Comma, ".." => Tok::DotDot, "=" => Tok::Equals, "==" => Tok::EqualsEquals, "=>" => Tok::EqualsGreaterThanCode(<&'input str>), "=>?" => Tok::EqualsGreaterThanQuestionCode(<&'input str>), "=>@L" => Tok::EqualsGreaterThanLookahead, "=>@R" => Tok::EqualsGreaterThanLookbehind, ">" => Tok::GreaterThan, "#" => Tok::Hash, "#![...]" => Tok::ShebangAttribute(<&'input str>), "{" => Tok::LeftBrace, "[" => Tok::LeftBracket, "(" => Tok::LeftParen, "<" => Tok::LessThan, "@L" => Tok::Lookahead, "@R" => Tok::Lookbehind, "->" => Tok::MinusGreaterThan, "+" => Tok::Plus, "?" => Tok::Question, "}" => Tok::RightBrace, "]" => Tok::RightBracket, ")" => Tok::RightParen, ";" => Tok::Semi, "*" => Tok::Star, "~~" => Tok::TildeTilde, "_" => Tok::Underscore, "StartGrammar" => Tok::StartGrammar, "StartPattern" => Tok::StartPattern, "StartMatchMapping" => Tok::StartMatchMapping, "StartTypeRef" => Tok::StartTypeRef, "StartGrammarWhereClauses" => Tok::StartGrammarWhereClauses, } } lalrpop-0.17.2/src/parser/lrgrammar.rs000064400000000000000000042241001352730447600160730ustar0000000000000000// auto-generated: "lalrpop 0.17.2" // sha256: e89b1a7457e0e4349c25a87ef72db0748cbace1dd8f18ec2bda33da2efc8db0 use string_cache::DefaultAtom as Atom; use grammar::parse_tree::*; use grammar::pattern::*; use std::iter::once; use tok::{self, Tok}; use util::strip; use lalrpop_util::ParseError; use super::Top; #[allow(unused_extern_crates)] extern crate lalrpop_util as ___lalrpop_util; #[allow(unused_imports)] use self::___lalrpop_util::state_machine as ___state_machine; #[cfg_attr(rustfmt, rustfmt_skip)] mod ___parse___Top { #![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens)] use string_cache::DefaultAtom as Atom; use grammar::parse_tree::*; use grammar::pattern::*; use std::iter::once; use tok::{self, Tok}; use util::strip; use lalrpop_util::ParseError; use super::super::Top; #[allow(unused_extern_crates)] extern crate lalrpop_util as ___lalrpop_util; #[allow(unused_imports)] use self::___lalrpop_util::state_machine as ___state_machine; use super::___ToTriple; #[allow(dead_code)] pub enum ___Symbol<'input> { Variant0(Tok<'input>), Variant1(&'input str), Variant2(::std::option::Option>), Variant3(TypeRef), Variant4(::std::option::Option), Variant5(Vec>), Variant6(::std::option::Option>>), Variant7(Condition), Variant8(::std::option::Option), Variant9(()), Variant10(Alternative), Variant11(::std::vec::Vec), Variant12(Conversion), Variant13(::std::vec::Vec), Variant14(FieldPattern), Variant15(::std::vec::Vec>), Variant16(Parameter), Variant17(::std::vec::Vec), Variant18(WhereClause), Variant19(::std::vec::Vec>), Variant20(Atom), Variant21(::std::vec::Vec), Variant22(Lifetime), Variant23(::std::vec::Vec), Variant24(MatchItem), Variant25(::std::vec::Vec), Variant26(NonterminalString), Variant27(::std::vec::Vec), Variant28(Pattern), Variant29(::std::vec::Vec>), Variant30(Symbol), Variant31(::std::vec::Vec), Variant32(TypeBound), Variant33(::std::vec::Vec>), Variant34(TypeBoundParameter), Variant35(::std::vec::Vec>), Variant36(TypeParameter), Variant37(::std::vec::Vec), Variant38(::std::vec::Vec), Variant39(usize), Variant40(ActionKind), Variant41(::std::option::Option), Variant42(::std::option::Option), Variant43(Vec), Variant44(Annotation), Variant45(::std::vec::Vec), Variant46((Atom, String)), Variant47(::std::option::Option<(Atom, String)>), Variant48(AssociatedType), Variant49(::std::vec::Vec), Variant50(Vec), Variant51(Vec), Variant52(Vec>), Variant53(Vec), Variant54(Vec), Variant55(Vec>), Variant56(Vec), Variant57(Vec), Variant58(Vec), Variant59(ConditionOp), Variant60(::std::option::Option), Variant61(EnumToken), Variant62(ExprSymbol), Variant63(GrammarItem), Variant64(::std::option::Option>), Variant65(Grammar), Variant66(::std::vec::Vec), Variant67(::std::option::Option), Variant68(::std::option::Option>), Variant69(::std::option::Option>), Variant70(::std::option::Option>), Variant71(::std::option::Option>>), Variant72(::std::option::Option), Variant73(MatchContents), Variant74(::std::option::Option), Variant75(TerminalString), Variant76(TerminalLiteral), Variant77(MatchToken), Variant78((NonterminalString, Vec)), Variant79(::std::option::Option), Variant80(Path), Variant81(::std::option::Option>), Variant82(PatternKind), Variant83(Vec), Variant84(Vec>), Variant85(RepeatOp), Variant86(String), Variant87(::std::vec::Vec), Variant88(::std::option::Option), Variant89(SymbolKind), Variant90(Top), Variant91(::std::option::Option>), Variant92(::std::option::Option>), Variant93(::std::option::Option), Variant94(Visibility), } const ___ACTION: &'static [i16] = &[ // State 0 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,4,5,6,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 1 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 2 0,0,0,15,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,0,0,0,0,0,18,0,0,0,0, // State 3 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 4 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,0,0,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 5 0,0,0,0,0,0,35,0,0,0,0,0,36,0,37,0,38,0,0,0,0,0,0,0,0,0,0,39,0,40,0,41,0,0,0,0,0,0,0,0,0,42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 6 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 7 0,0,0,-123,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-123,-123,0,-123,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-123,0,0,0,-123,0,0,0,0,0,0, // State 8 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,50,0,0,0,0,0,0,0,0,0,0, // State 9 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 10 0,0,0,-422,-422,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-422,0,0,0,0,0,-422,0,0,0,0, // State 11 0,0,0,15,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,54,0,0,0,0,0,18,0,0,0,0, // State 12 0,0,0,-497,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-497,0,0,0,0,0,-497,0,0,0,0, // State 13 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,57,0,0,0,0,0,18,0,0,0,0, // State 14 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,58,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 15 0,0,0,-419,-419,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-419,0,0,0,0,0,-419,0,0,0,0, // State 16 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,63,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 17 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,65,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 18 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 19 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,-146,0,0,0,0,0,0,0,0,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,72,0,0,0,0,0,0,0,0,0,0,0, // State 20 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 21 -414,0,0,-414,0,0,-414,-414,-414,-414,-414,0,0,0,0,-414,-414,0,0,-414,-414,-414,-414,-414,-414,-414,-414,0,-414,-414,0,-414,-414,0,0,0,0,0,-414,0,0,0,0,0,0,0,0,0,-414,0,0,0,0,0,0,0,-414,0, // State 22 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-446,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 23 -413,0,0,-413,0,0,-413,-413,-413,-413,-413,0,0,0,0,-413,-413,0,0,-413,-413,-413,-413,-413,-413,-413,-413,0,-413,-413,0,-413,-413,0,0,0,0,0,-413,0,0,0,0,0,0,0,0,0,-413,0,0,0,0,0,0,0,-413,0, // State 24 -412,0,0,-412,0,0,-412,-412,-412,-412,-412,0,0,0,0,-412,-412,0,0,-412,-412,-412,-412,-412,-412,-412,-412,0,-412,-412,0,-412,-412,0,0,0,0,0,-412,0,0,0,0,0,0,0,0,0,-412,0,0,0,0,0,0,0,-412,0, // State 25 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 26 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-447,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 27 -415,0,0,-415,0,0,-415,-415,-415,-415,-415,0,0,0,0,-415,-415,0,0,-415,-415,-415,-415,-415,-415,-415,-415,0,-415,-415,0,-415,-415,0,0,0,0,0,-415,0,0,0,0,0,0,0,0,0,-415,0,0,0,0,0,0,0,-415,0, // State 28 -424,0,0,-424,0,0,-424,-424,-424,-424,-424,0,0,0,0,-424,-424,0,0,-424,-424,-424,-424,-424,-424,-424,-424,0,-424,-424,0,-424,-424,0,0,0,0,0,-424,0,0,0,0,0,0,0,0,0,-424,0,0,0,0,0,0,0,-424,0, // State 29 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 30 0,0,0,0,0,0,-386,-386,0,-386,-386,0,0,-386,74,-386,-386,-386,0,0,0,0,0,-386,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-386,-386,0, // State 31 0,0,0,0,0,0,75,-403,0,0,-403,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,76,-403,0, // State 32 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 33 0,0,0,0,0,0,0,-388,0,0,-388,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-388,0, // State 34 0,0,0,0,0,0,35,-158,0,0,0,0,36,0,37,0,38,0,0,0,0,0,0,0,0,0,0,39,0,40,0,41,0,0,0,0,0,0,0,0,0,42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 35 0,0,0,0,0,0,0,-399,0,0,-399,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-399,0, // State 36 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 37 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 38 0,0,0,0,0,0,0,-402,0,0,-402,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-402,0, // State 39 0,0,0,0,0,0,-357,-357,0,-357,-357,0,0,-357,-357,-357,-357,-357,0,0,0,0,0,-357,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-357,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-357,-357,0, // State 40 0,0,0,0,0,0,-358,-358,0,-358,-358,0,0,-358,-358,-358,-358,-358,0,0,0,0,0,-358,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-358,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-358,-358,0, // State 41 0,0,0,0,0,0,0,-398,0,0,-398,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-398,0, // State 42 0,0,0,0,0,0,0,-481,0,-481,-481,0,0,-481,0,-481,83,-481,0,0,0,0,0,-481,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-481,0,0, // State 43 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 44 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,93,0,0,0,0,0,0,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 45 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,101,0,0,0,0,0,0,0, // State 46 0,0,0,45,0,46,47,-174,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 47 0,0,0,0,0,0,0,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,106,0,0,0,0,0,0,0,0,0,0,0, // State 48 0,0,0,-124,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-124,-124,0,-124,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-124,0,0,0,-124,0,0,0,0,0,0, // State 49 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,110,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 50 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,111,0,0,0,0,0,0,0,0,0,0, // State 51 0,0,0,-423,-423,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-423,0,0,0,0,0,-423,0,0,0,0, // State 52 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,113,0,0,0,0,0,18,0,0,0,0, // State 53 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,117,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 54 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,118,0,0,0,0,0,0,0,0,0,0, // State 55 0,0,0,-498,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-498,0,0,0,0,0,-498,0,0,0,0, // State 56 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,122,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 57 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 58 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,125,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 59 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 60 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,129,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 61 0,0,0,0,0,0,0,-142,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 62 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 63 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-170,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 64 0,0,0,-494,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-494,-494,0,-494,0,0,0,0,0,0,0,0,0,0,0,0,0,-494,0,-494,0,-494,0,-494,0,-494,0,0,0,0, // State 65 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,-148,0,0,0,0,0,0,0,0,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,72,0,0,0,0,0,0,0,0,0,0,0, // State 66 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-354,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 67 0,0,0,0,0,0,0,0,0,0,152,0,0,0,0,-145,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 68 0,0,0,0,0,0,0,0,0,0,0,0,0,153,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 69 0,0,0,0,0,0,0,0,0,0,0,0,0,154,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 70 0,0,0,-359,0,-359,-359,0,0,-359,-359,0,0,-359,-359,-359,0,0,0,0,0,0,0,-359,0,0,0,0,0,-359,0,-359,0,0,0,0,0,0,0,0,0,0,-359,0,0,0,0,0,0,0,-359,0,0,0,0,0,0,0, // State 71 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,155,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 72 0,0,0,0,0,0,-387,-387,0,-387,-387,0,0,-387,156,-387,-387,-387,0,0,0,0,0,-387,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-387,-387,0, // State 73 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-48,0,-48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 74 0,0,0,0,0,0,35,-158,0,0,0,0,36,0,37,0,38,0,0,0,0,0,0,0,0,0,0,39,0,40,0,41,0,0,0,0,0,0,0,0,0,42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 75 0,0,0,0,0,0,0,0,0,0,0,0,161,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,162,0, // State 76 0,0,0,0,0,0,35,-160,0,0,0,0,36,0,37,0,38,0,0,0,0,0,0,0,0,0,0,39,0,40,0,41,0,0,0,0,0,0,0,0,0,42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 77 0,0,0,0,0,0,0,164,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 78 0,0,0,0,0,0,0,-157,0,0,165,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 79 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 80 0,0,0,0,0,0,-384,-384,0,-384,-384,0,0,-384,74,-384,-384,-384,0,0,0,0,0,-384,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-384,-384,0, // State 81 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,167,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 82 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,-178,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 83 -441,0,0,-441,0,0,-441,-441,-441,-441,-441,0,0,0,0,-441,-441,0,0,-441,-441,-441,-441,-441,-441,-441,-441,0,-441,-441,0,-441,-441,0,0,0,0,0,-441,0,0,0,0,0,0,0,0,0,-441,0,0,0,0,0,0,0,-441,0, // State 84 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,173,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 85 -439,0,0,-439,0,0,-439,-439,-439,-439,-439,0,0,0,0,-439,-439,0,0,-439,-439,-439,-439,-439,-439,-439,-439,0,-439,-439,0,-439,-439,0,0,0,0,0,-439,0,0,0,0,0,0,0,0,0,-439,0,0,0,0,0,0,0,-439,0, // State 86 0,0,0,174,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 87 -428,0,0,-428,0,0,-428,-428,176,177,-428,0,0,0,0,-428,-428,0,0,-428,-428,-428,-428,-428,178,-428,-428,0,-428,-428,0,-428,-428,0,0,0,0,0,-428,0,0,0,0,0,0,0,0,0,-428,0,0,0,0,0,0,0,-428,0, // State 88 -433,0,0,-433,0,0,-433,-433,-433,-433,-433,0,0,0,0,-433,-433,0,0,-433,-433,-433,-433,-433,-433,-433,-433,0,-433,-433,0,-433,-433,0,0,0,0,0,-433,0,0,0,0,0,0,0,0,0,-433,0,0,0,0,0,0,0,-433,0, // State 89 -435,0,0,-435,0,0,-435,-435,-435,-435,-435,0,0,0,0,-435,-435,0,0,-435,-435,-435,-435,-435,-435,-435,-435,0,-435,-435,0,-435,-435,0,0,0,0,0,-435,0,0,0,0,0,0,0,0,0,-435,0,0,0,0,0,0,0,-435,0, // State 90 -445,0,0,-445,0,0,-445,-445,-445,-445,-445,0,0,0,0,-445,-445,0,0,-445,-445,-445,-445,-445,-445,-445,-445,0,-445,-445,0,-445,-445,0,0,0,0,0,-445,0,0,0,0,0,0,0,0,0,-445,0,0,0,0,0,0,0,-445,0, // State 91 91,0,0,0,0,0,92,-191,0,0,0,0,0,0,0,0,93,0,0,0,0,0,0,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 92 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,95,0,96,184,0,185,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,186,0,0,0,0,0,0,0, // State 93 -443,0,0,-443,0,0,-443,-443,-443,-443,-443,0,0,0,0,-443,-443,0,0,-443,-443,-443,-443,-443,-443,-443,-443,0,-443,-443,0,-443,-443,0,0,0,0,0,-443,0,0,0,0,0,0,0,0,0,-443,0,0,0,0,0,0,0,-443,0, // State 94 -444,0,0,-444,0,0,-444,-444,-444,-444,-444,0,0,0,0,-444,-444,0,0,-444,-444,-444,-444,-444,-444,-444,-444,0,-444,-444,0,-444,-444,0,0,0,0,0,-444,0,0,0,0,0,0,0,0,0,-444,0,0,0,0,0,0,0,-444,0, // State 95 -190,0,0,-190,0,0,-190,-190,-190,-190,-190,0,0,0,0,-190,-190,0,0,-190,-190,-190,-190,-190,-190,-190,-190,0,-190,-190,0,-190,-190,0,0,0,0,0,-190,0,0,0,0,0,0,0,0,0,-190,0,0,0,0,0,0,0,-190,0, // State 96 -440,0,0,-440,0,0,-440,-440,-440,-440,-440,0,0,0,0,-440,-440,0,0,-440,-440,-440,-440,-440,-440,-440,-440,0,-440,-440,0,-440,-440,0,0,0,0,0,-440,0,0,0,0,0,0,0,0,0,-440,0,0,0,0,0,0,0,-440,0, // State 97 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-362,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 98 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,188,0,0,0,0,0,0,0, // State 99 0,0,0,0,0,0,0,-479,0,-479,-479,0,0,-479,0,-479,0,-479,0,0,0,0,0,-479,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-479,0,0, // State 100 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 101 0,0,0,45,0,46,47,-176,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 102 0,0,0,0,0,0,0,191,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 103 0,0,0,0,0,0,0,-173,0,0,192,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 104 0,0,0,0,0,0,193,-483,0,-483,-483,0,0,-483,0,-483,194,-483,0,0,0,0,0,-483,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-483,0,0, // State 105 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,195,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 106 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,197,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 107 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,200,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 108 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,201,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 109 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 110 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,206,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 111 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,207,0,0,0,0,0,0,0,0,0,0, // State 112 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,211,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 113 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,213,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 114 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,216,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 115 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,217,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 116 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 117 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,222,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 118 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 119 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,227,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 120 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,228,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 121 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 122 0,0,0,0,0,0,231,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,232,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 123 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,233,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 124 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 125 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,236,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 126 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,237,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 127 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 128 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 129 0,0,0,0,0,0,0,-144,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 130 0,0,0,0,0,0,0,241,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 131 0,0,0,0,0,0,0,-141,0,0,242,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 132 0,0,0,0,0,0,0,0,0,0,0,0,0,243,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 133 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,145,0,0,0,0,0,0, // State 134 0,0,0,-334,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-334,-334,0,-334,0,0,0,0,0,0,0,0,0,0,0,0,0,-334,0,0,0,-334,0,-334,0,-334,0,0,0,0, // State 135 0,0,0,-338,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-338,-338,0,-338,0,0,0,0,0,0,0,0,0,0,0,0,0,-338,0,0,0,-338,0,-338,0,-338,0,0,0,0, // State 136 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 137 0,0,0,-333,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-333,-333,0,-333,0,0,0,0,0,0,0,0,0,0,0,0,0,-333,0,0,0,-333,0,-333,0,-333,0,0,0,0, // State 138 0,0,0,-371,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-371,-371,0,-371,0,0,0,0,0,0,0,0,0,0,0,246,0,-371,0,0,0,-371,0,-371,0,-371,0,0,0,0, // State 139 0,0,0,-335,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-335,-335,0,-335,0,0,0,0,0,0,0,0,0,0,0,0,0,-335,0,0,0,-335,0,-335,0,-335,0,0,0,0, // State 140 0,0,0,-332,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-332,-332,0,-332,0,0,0,0,0,0,0,0,0,0,0,0,0,-332,0,0,0,-332,0,-332,0,-332,0,0,0,0, // State 141 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,250,251,0,98,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 142 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,0,0, // State 143 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,253,0,0, // State 144 0,0,0,0,0,0,254,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-500,-500,0,-500,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 145 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-172,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 146 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,256,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 147 0,0,0,0,0,0,0,0,0,0,-471,0,0,0,0,0,0,0,0,0,0,0,0,-471,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 148 0,0,0,0,0,0,0,0,0,0,-470,0,0,0,0,0,0,0,0,0,0,0,0,-470,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 149 0,0,0,0,0,0,0,0,0,0,257,0,0,0,0,0,0,0,0,0,0,0,0,-169,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 150 0,0,0,0,0,0,0,0,0,0,258,0,0,0,0,-147,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 151 0,0,0,-43,0,-43,-43,0,0,0,0,0,0,0,-43,-43,0,0,0,0,0,0,0,0,0,0,0,0,0,-43,-43,-43,0,0,0,0,0,0,0,0,0,0,-43,0,0,0,-43,0,0,0,0,0,0,0,0,0,0,0, // State 152 0,0,0,0,0,0,0,0,0,0,-405,0,0,0,0,-405,0,0,0,0,0,0,0,0,0,0,0,0,0,0,71,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 153 0,0,0,0,0,0,0,0,0,0,-409,0,0,0,37,-409,0,0,0,0,0,0,0,0,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,268,0,0,0,0,0,0,0,0,0,0,0, // State 154 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-170,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 155 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-49,0,-49,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 156 0,0,0,0,0,0,0,270,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 157 0,0,0,0,0,0,0,0,0,0,0,0,272,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,273,0, // State 158 0,0,0,0,0,0,0,0,0,0,274,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,275,0, // State 159 0,0,0,0,0,0,0,0,0,0,0,0,0,276,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 160 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,277,0, // State 161 0,0,0,0,0,0,0,-393,0,0,-393,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-393,0, // State 162 0,0,0,0,0,0,0,-159,0,0,278,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 163 0,0,0,0,0,0,0,-401,0,0,-401,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-401,0, // State 164 0,0,0,0,0,0,-68,-68,0,0,0,0,-68,0,-68,0,-68,0,0,0,0,0,0,0,0,0,0,-68,0,-68,0,-68,0,0,0,0,0,0,0,0,0,-68,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 165 0,0,0,0,0,0,-385,-385,0,-385,-385,0,0,-385,156,-385,-385,-385,0,0,0,0,0,-385,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-385,-385,0, // State 166 0,0,0,0,0,0,0,-400,0,0,-400,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-400,0, // State 167 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,-180,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 168 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,280,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 169 0,0,0,0,0,0,0,0,0,0,-491,0,0,0,0,0,0,0,0,0,0,0,0,-491,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 170 0,0,0,0,0,0,0,0,0,0,-490,0,0,0,0,0,0,0,0,0,0,0,0,-490,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 171 0,0,0,0,0,0,0,0,0,0,281,0,0,0,0,0,0,0,0,0,0,0,0,-177,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 172 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,93,0,0,0,0,0,0,-162,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 173 0,0,0,0,0,0,0,-475,0,-475,-475,0,0,-475,0,-475,0,-475,0,0,0,0,0,-475,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-475,0,0, // State 174 -434,0,0,-434,0,0,-434,-434,-434,-434,-434,0,0,0,0,-434,-434,0,0,-434,-434,-434,-434,-434,-434,-434,-434,0,-434,-434,0,-434,-434,0,0,0,0,0,-434,0,0,0,0,0,0,0,0,0,-434,0,0,0,0,0,0,0,-434,0, // State 175 -417,0,0,-417,0,0,-417,-417,-417,-417,-417,0,0,0,0,-417,-417,0,0,-417,-417,-417,-417,-417,-417,-417,-417,0,-417,-417,0,-417,-417,0,0,0,0,0,-417,0,0,0,0,0,0,0,0,0,-417,0,0,0,0,0,0,0,-417,0, // State 176 -416,0,0,-416,0,0,-416,-416,-416,-416,-416,0,0,0,0,-416,-416,0,0,-416,-416,-416,-416,-416,-416,-416,-416,0,-416,-416,0,-416,-416,0,0,0,0,0,-416,0,0,0,0,0,0,0,0,0,-416,0,0,0,0,0,0,0,-416,0, // State 177 -418,0,0,-418,0,0,-418,-418,-418,-418,-418,0,0,0,0,-418,-418,0,0,-418,-418,-418,-418,-418,-418,-418,-418,0,-418,-418,0,-418,-418,0,0,0,0,0,-418,0,0,0,0,0,0,0,0,0,-418,0,0,0,0,0,0,0,-418,0, // State 178 0,0,0,0,0,0,0,285,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 179 -431,0,0,0,0,0,-431,-431,0,0,-431,0,0,0,0,-431,-431,0,0,-431,-431,-431,-431,0,0,-431,-431,0,-431,-431,0,-431,-431,0,0,0,0,0,-431,0,0,0,0,0,0,0,0,0,-431,0,0,0,0,0,0,0,-431,0, // State 180 91,0,0,0,0,0,92,-192,0,0,0,0,0,0,0,0,93,0,0,0,0,0,0,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 181 0,0,0,0,0,0,0,0,0,0,0,0,0,287,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 182 0,0,0,0,0,0,0,0,176,177,0,0,0,0,0,0,0,0,0,0,0,0,0,288,178,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 183 0,0,0,0,0,0,0,0,-440,-440,0,0,0,-357,0,0,0,0,0,0,0,0,0,-440,-440,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 184 0,0,0,0,0,0,0,0,0,0,0,0,0,-358,0,0,-362,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 185 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 186 0,0,0,0,0,0,0,-478,0,-478,-478,0,0,-478,0,-478,0,-478,0,0,0,0,0,-478,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-478,0,0, // State 187 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 188 0,0,0,0,0,0,0,-477,0,-477,-477,0,0,-477,0,-477,0,-477,0,0,0,0,0,-477,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-477,0,0, // State 189 0,0,0,0,0,0,0,-175,0,0,291,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 190 0,0,0,0,0,0,0,-474,0,-474,-474,0,0,-474,0,-474,0,-474,0,0,0,0,0,-474,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-474,0,0, // State 191 0,0,0,-93,0,-93,-93,-93,0,0,0,0,0,0,-93,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-93,0,-93,0,0,0,0,0,0,0,0,0,0,-93,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 192 0,0,0,45,0,46,47,-174,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 193 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,-178,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 194 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-170,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 195 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,295,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 196 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 197 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,298,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 198 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,299,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 199 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 200 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 201 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 202 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,303,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 203 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,306,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 204 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,307,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 205 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 206 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,312,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 207 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,314,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 208 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,317,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 209 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,318,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 210 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 211 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,320,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 212 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 213 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,323,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 214 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,324,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 215 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 216 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 217 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 218 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,328,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 219 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,331,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 220 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,332,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 221 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 222 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,334,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 223 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 224 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,337,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 225 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,338,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 226 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 227 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 228 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 229 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,341,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 230 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 231 0,0,0,-120,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-120,-120,0,-120,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-120,0,0,0,-120,0,0,0,0,0,0, // State 232 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 233 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 234 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,344,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 235 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 236 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 237 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 238 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 239 0,0,0,0,0,0,0,-143,0,0,347,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 240 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-343,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-343,0,0,0, // State 241 0,0,0,0,0,0,0,-38,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-38,0,-38,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 242 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 243 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,250,251,0,98,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 244 0,0,0,-339,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-339,-339,0,-339,0,0,0,0,0,0,0,0,0,0,0,0,0,-339,0,0,0,-339,0,-339,0,-339,0,0,0,0, // State 245 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,350,0,0, // State 246 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,351,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 247 0,0,0,0,0,0,0,0,0,0,0,0,0,352,0,0,0,353,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 248 0,0,0,0,0,0,0,0,0,0,0,0,0,-379,0,0,0,-379,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 249 0,0,0,0,0,0,0,0,0,0,0,0,0,-380,0,0,0,-380,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 250 0,-381,-381,0,0,0,0,0,0,0,-381,0,0,-381,0,0,0,-381,-381,0,0,0,0,-381,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-381, // State 251 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,357,0,0,0,0,0,0,0,358,0,0,0,359,0, // State 252 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,0,0,29,0,0,366,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-150,0, // State 253 0,0,0,0,0,0,0,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 254 0,0,0,0,0,0,0,0,0,0,368,0,0,0,0,0,0,0,0,0,0,0,0,-171,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 255 0,0,0,0,0,0,-346,0,0,0,0,0,0,0,0,-346,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-346,0,0,0, // State 256 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-88,0,0,0,0,0,-88,-88,-88,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 257 0,0,0,-44,0,-44,-44,0,0,0,0,0,0,0,-44,-44,0,0,0,0,0,0,0,0,0,0,0,0,0,-44,-44,-44,0,0,0,0,0,0,0,0,0,0,-44,0,0,0,-44,0,0,0,0,0,0,0,0,0,0,0, // State 258 0,0,0,0,0,0,0,0,0,0,-407,0,0,0,0,-407,0,0,0,0,0,0,0,0,0,0,0,0,0,0,71,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 259 0,0,0,0,0,0,0,0,0,370,-404,0,0,0,0,-404,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 260 0,0,0,0,0,0,0,0,0,0,-349,0,0,0,0,-349,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 261 0,0,0,0,0,0,0,0,0,0,-411,0,0,0,37,-411,0,0,0,0,0,0,0,0,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,268,0,0,0,0,0,0,0,0,0,0,0, // State 262 0,0,0,0,0,0,0,0,0,-453,-453,0,0,0,0,-453,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 263 0,0,0,0,0,0,372,0,0,-461,-461,0,0,0,0,-461,373,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 264 0,0,0,0,0,0,0,0,0,0,-469,0,0,0,0,-469,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 265 0,0,0,0,0,0,0,0,0,374,-408,0,0,0,0,-408,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 266 0,0,0,0,0,0,0,0,0,0,-351,0,0,0,0,-351,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 267 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,375,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 268 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,376,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 269 0,0,0,0,0,0,0,-391,0,0,-391,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-391,0, // State 270 0,0,0,0,0,0,0,0,0,0,377,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,378,0, // State 271 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,379,0, // State 272 0,0,0,0,0,0,0,-395,0,0,-395,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-395,0, // State 273 0,0,0,0,0,0,0,0,0,0,0,0,-33,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-33,0,-33,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-33,0, // State 274 0,0,0,0,0,0,0,-392,0,0,-392,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-392,0, // State 275 0,0,0,0,0,0,35,0,0,0,0,0,36,0,37,0,38,0,0,0,0,0,0,0,0,0,0,39,0,40,0,41,0,0,0,0,0,0,0,0,0,42,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 276 0,0,0,0,0,0,0,-396,0,0,-396,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-396,0, // State 277 0,0,0,0,0,0,-69,-69,0,0,0,0,-69,0,-69,0,-69,0,0,0,0,0,0,0,0,0,0,-69,0,-69,0,-69,0,0,0,0,0,0,0,0,0,-69,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 278 0,0,0,0,0,0,0,0,0,0,381,0,0,0,0,0,0,0,0,0,0,0,0,-179,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 279 0,0,0,0,0,0,0,-480,0,-480,-480,0,0,-480,0,-480,0,-480,0,0,0,0,0,-480,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-480,0,0, // State 280 0,0,0,-98,0,-98,-98,0,0,0,0,0,0,0,-98,0,0,0,0,0,0,0,0,-98,0,0,0,0,0,-98,-98,-98,0,0,0,0,0,0,0,0,0,0,-98,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 281 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,93,0,0,0,0,0,0,-164,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 282 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,383,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 283 0,0,0,0,0,0,0,0,0,0,384,0,0,0,0,0,0,0,0,0,0,0,0,-161,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 284 -442,0,0,-442,0,0,-442,-442,-442,-442,-442,0,0,0,0,-442,-442,0,0,-442,-442,-442,-442,-442,-442,-442,-442,0,-442,-442,0,-442,-442,0,0,0,0,0,-442,0,0,0,0,0,0,0,0,0,-442,0,0,0,0,0,0,0,-442,0, // State 285 -432,0,0,0,0,0,-432,-432,0,0,-432,0,0,0,0,-432,-432,0,0,-432,-432,-432,-432,0,0,-432,-432,0,-432,-432,0,-432,-432,0,0,0,0,0,-432,0,0,0,0,0,0,0,0,0,-432,0,0,0,0,0,0,0,-432,0, // State 286 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 287 -427,0,0,-427,0,0,-427,-427,0,0,-427,0,0,0,0,-427,-427,0,0,-427,-427,-427,-427,-427,0,-427,-427,0,-427,-427,0,-427,-427,0,0,0,0,0,-427,0,0,0,0,0,0,0,0,0,-427,0,0,0,0,0,0,0,-427,0, // State 288 0,0,0,0,0,0,0,0,0,0,0,0,0,386,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 289 0,0,0,0,0,0,0,-476,0,-476,-476,0,0,-476,0,-476,0,-476,0,0,0,0,0,-476,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-476,0,0, // State 290 0,0,0,-94,0,-94,-94,-94,0,0,0,0,0,0,-94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-94,0,-94,0,0,0,0,0,0,0,0,0,0,-94,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 291 0,0,0,0,0,0,0,387,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 292 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,388,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 293 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,389,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 294 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 295 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 296 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,391,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 297 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 298 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 299 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 300 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 301 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,394,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 302 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 303 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,397,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 304 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,398,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 305 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 306 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 307 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 308 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,402,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 309 0,0,0,0,0,0,62,0,0,0,0,0,0,0,0,405,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 310 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,406,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 311 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 312 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,408,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 313 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 314 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,411,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 315 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,412,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 316 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 317 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 318 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 319 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 320 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 321 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,416,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 322 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 323 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 324 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 325 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 326 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,419,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 327 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 328 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,422,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 329 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,423,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 330 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 331 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 332 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 333 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 334 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 335 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,427,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 336 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 337 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 338 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 339 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 340 0,0,0,-119,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-119,-119,0,-119,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-119,0,0,0,-119,0,0,0,0,0,0, // State 341 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,430,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 342 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 343 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 344 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 345 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 346 0,0,0,0,0,0,0,-39,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-39,0,-39,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 347 0,0,0,0,0,0,0,-340,0,0,-340,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 348 0,0,0,0,0,0,0,0,0,0,0,0,0,432,0,0,0,433,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 349 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,0,0,29,0,0,366,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-150,0, // State 350 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-154,0,0,0,0,0,251,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 351 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 352 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,93,0,0,443,444,445,446,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,447,0,0,0,0,0,0,448,0,0, // State 353 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-131,0,0,0,0,0,0,0,-131,0,0,0,-131,0, // State 354 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,357,0,0,0,0,0,0,0,358,0,0,0,451,0, // State 355 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,358,0,0,0,453,0, // State 356 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 357 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 358 0,0,0,-197,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-197,-197,0,-197,0,0,0,0,0,0,0,0,0,0,0,0,0,-197,0,0,0,-197,0,-197,0,-197,0,0,0,0, // State 359 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,0,0,29,0,0,366,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-152,0, // State 360 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-363,0, // State 361 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,457,0, // State 362 0,0,0,0,0,0,0,0,0,0,458,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-149,0, // State 363 0,0,0,0,0,0,0,0,0,0,-365,0,0,0,0,0,0,0,0,459,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-365,0, // State 364 0,0,0,0,0,0,0,0,0,0,-370,0,0,0,0,0,0,0,0,-370,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-370,0, // State 365 0,0,0,0,0,0,0,0,0,0,-364,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-364,0, // State 366 0,0,0,0,0,0,0,460,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 367 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-89,0,0,0,0,0,-89,-89,-89,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 368 0,0,0,0,0,0,0,0,0,461,-406,0,0,0,0,-406,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 369 0,0,0,0,0,0,0,0,0,0,-53,0,0,0,0,-53,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-53,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 370 0,0,0,0,0,0,0,0,0,462,-410,0,0,0,0,-410,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 371 0,0,0,45,0,46,47,-174,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 372 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,-166,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 373 0,0,0,0,0,0,0,0,0,0,-78,0,0,0,-78,-78,0,0,0,0,0,0,0,0,0,0,0,0,0,-78,-78,-78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-78,0,0,0,0,0,0,0,0,0,0,0, // State 374 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-170,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 375 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 376 0,0,0,0,0,0,0,0,0,0,0,0,-34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-34,0,-34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-34,0, // State 377 0,0,0,0,0,0,0,-394,0,0,-394,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-394,0, // State 378 0,0,0,0,0,0,0,-397,0,0,-397,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-397,0, // State 379 0,0,0,0,0,0,0,0,0,0,-199,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-199,0, // State 380 0,0,0,-99,0,-99,-99,0,0,0,0,0,0,0,-99,0,0,0,0,0,0,0,0,-99,0,0,0,0,0,-99,-99,-99,0,0,0,0,0,0,0,0,0,0,-99,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 381 0,0,0,0,0,0,0,0,0,0,472,0,0,0,0,0,0,0,0,0,0,0,0,-163,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 382 -438,0,0,-438,0,0,-438,-438,-438,-438,-438,0,0,0,0,-438,-438,0,0,-438,-438,-438,-438,-438,-438,-438,-438,0,-438,-438,0,-438,-438,0,0,0,0,0,-438,0,0,0,0,0,0,0,0,0,-438,0,0,0,0,0,0,0,-438,0, // State 383 -73,0,0,0,0,0,-73,0,0,0,0,0,0,0,0,0,-73,0,0,0,0,0,0,-73,0,-73,-73,0,-73,-73,0,-73,-73,0,0,0,0,0,-73,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 384 0,0,0,0,0,0,0,0,176,177,0,0,0,0,0,0,0,0,0,0,0,0,0,473,178,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 385 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 386 0,0,0,0,0,0,0,-487,0,-487,-487,475,0,-487,0,-487,0,-487,0,0,0,0,0,-487,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-487,0,0, // State 387 0,0,0,0,0,0,0,-482,0,-482,-482,0,0,-482,0,-482,0,-482,0,0,0,0,0,-482,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-482,0,0, // State 388 0,0,0,0,0,0,0,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 389 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 390 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 391 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 392 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 393 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 394 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 395 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,479,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 396 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 397 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 398 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 399 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 400 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,482,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 401 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 402 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,485,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0, // State 403 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,486,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 404 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 405 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 406 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 407 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 408 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 409 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,490,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 410 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 411 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 412 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 413 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 414 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 415 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 416 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 417 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 418 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 419 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 420 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,495,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 421 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 422 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 423 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 424 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 425 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 426 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 427 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 428 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 429 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,499,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 430 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 431 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 432 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,93,0,0,443,444,445,446,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,447,0,0,0,0,0,0,448,0,0, // State 433 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,502,0, // State 434 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-156,0,0,0,0,0,251,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 435 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,504,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 436 0,0,0,0,0,0,0,0,0,0,505,0,0,0,0,0,0,0,0,0,0,0,0,-153,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 437 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 438 0,0,0,0,0,0,0,0,0,0,-113,0,0,0,0,-113,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-113,0, // State 439 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,507,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 440 0,0,0,-376,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-376,-376,0,-376,0,0,0,0,0,0,0,0,0,0,0,0,0,-376,0,0,0,-376,0,-376,0,-376,0,0,0,0, // State 441 91,0,0,0,0,0,92,0,0,0,-111,0,0,0,0,-111,93,0,0,443,444,445,446,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,509,0,0,0,0,0,0,0,-111,0, // State 442 0,0,0,0,0,0,0,0,0,0,-104,0,0,0,0,-104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-104,0, // State 443 0,0,0,0,0,0,0,0,0,0,-105,0,0,0,0,-105,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-105,0, // State 444 0,0,0,0,0,0,0,0,0,0,-102,0,0,0,0,-102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-102,0, // State 445 0,0,0,0,0,0,0,0,0,0,-103,0,0,0,0,-103,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-103,0, // State 446 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,251,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 447 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,93,0,0,443,444,445,446,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,447,0,0,0,0,0,0,0,-134,0, // State 448 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-132,0,0,0,0,0,0,0,-132,0,0,0,-132,0, // State 449 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,358,0,0,0,516,0, // State 450 0,0,0,-198,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-198,-198,0,-198,0,0,0,0,0,0,0,0,0,0,0,0,0,-198,0,0,0,-198,0,-198,0,-198,0,0,0,0, // State 451 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,358,0,0,0,517,0, // State 452 0,0,0,-193,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-193,-193,0,-193,0,0,0,0,0,0,0,0,0,0,0,0,0,-193,0,0,0,-193,0,-193,0,-193,0,0,0,0, // State 453 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,518,0,0, // State 454 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,519,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 455 0,0,0,0,0,0,0,0,0,0,520,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-151,0, // State 456 0,0,0,-373,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-373,-373,0,-373,0,0,0,0,0,0,0,0,0,0,0,-373,0,-373,0,0,0,-373,0,-373,0,-373,0,0,0,0, // State 457 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-58,0,0,0,0,0,-58,0,0,-58,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-58,0, // State 458 0,0,0,0,0,0,0,0,0,0,-366,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-366,0, // State 459 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-499,-499,0,-499,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 460 0,0,0,0,0,0,0,0,0,0,-54,0,0,0,0,-54,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-54,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 461 0,0,0,0,0,0,0,0,0,0,-79,0,0,0,-79,-79,0,0,0,0,0,0,0,0,0,0,0,0,0,-79,-79,-79,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-79,0,0,0,0,0,0,0,0,0,0,0, // State 462 0,0,0,0,0,0,0,521,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 463 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,-168,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 464 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,523,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 465 0,0,0,0,0,0,0,0,0,0,-386,0,0,0,74,0,-386,524,0,0,0,0,0,-386,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 466 0,0,0,0,0,0,0,0,0,0,-464,0,0,0,0,0,0,0,0,0,0,0,0,-464,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 467 0,0,0,0,0,0,0,0,0,0,525,0,0,0,0,0,0,0,0,0,0,0,0,-165,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 468 0,0,0,0,0,0,0,0,0,0,-465,0,0,0,0,0,0,0,0,0,0,0,0,-465,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 469 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,526,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 470 0,0,0,0,0,0,0,0,0,0,0,0,0,527,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 471 -74,0,0,0,0,0,-74,0,0,0,0,0,0,0,0,0,-74,0,0,0,0,0,0,-74,0,-74,-74,0,-74,-74,0,-74,-74,0,0,0,0,0,-74,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 472 -426,0,0,-426,0,0,-426,-426,0,0,-426,0,0,0,0,-426,-426,0,0,-426,-426,-426,-426,-426,0,-426,-426,0,-426,-426,0,-426,-426,0,0,0,0,0,-426,0,0,0,0,0,0,0,0,0,-426,0,0,0,0,0,0,0,-426,0, // State 473 0,0,0,0,0,0,0,0,176,177,0,0,0,0,0,0,0,0,0,0,0,0,0,528,178,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 474 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 475 0,0,0,0,0,0,530,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 476 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 477 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 478 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 479 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 480 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 481 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 482 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 483 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,533,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 484 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 485 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 486 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 487 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 488 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 489 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 490 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 491 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 492 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 493 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 494 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 495 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 496 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 497 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 498 0,0,0,0,0,0,0,538,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 499 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,539,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 500 0,0,0,-377,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-377,-377,0,-377,0,0,0,0,0,0,0,0,0,0,0,0,0,-377,0,0,0,-377,0,-377,0,-377,0,0,0,0, // State 501 0,0,0,-372,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-372,-372,0,-372,0,0,0,0,0,0,0,0,0,0,0,-372,0,-372,0,0,0,-372,0,-372,0,-372,0,0,0,0, // State 502 0,0,0,0,0,0,0,0,0,0,540,0,0,0,0,0,0,0,0,0,0,0,0,-155,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 503 0,0,0,0,0,0,0,0,0,0,0,0,0,-378,0,0,0,-378,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 504 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-63,0,0,0,0,0,-63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 505 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,93,0,0,443,444,445,446,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,447,0,0,0,0,0,0,448,0,0, // State 506 0,0,0,-116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-116,-116,0,-116,0,0,0,0,0,0,0,0,0,0,0,0,0,-116,0,0,0,-116,0,-116,0,-116,0,0,0,0, // State 507 0,0,0,0,0,0,0,0,0,0,-110,0,0,0,0,-110,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-110,0, // State 508 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,251,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 509 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,443,444,445,446,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 510 0,545,546,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,547,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,548, // State 511 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,93,0,0,443,444,445,446,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,447,0,0,0,0,0,0,0,-136,0, // State 512 0,0,0,0,0,0,0,0,0,0,550,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-133,0, // State 513 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,551,0, // State 514 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,358,0,0,0,552,0, // State 515 0,0,0,-195,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-195,-195,0,-195,0,0,0,0,0,0,0,0,0,0,0,0,0,-195,0,0,0,-195,0,-195,0,-195,0,0,0,0, // State 516 0,0,0,-194,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-194,-194,0,-194,0,0,0,0,0,0,0,0,0,0,0,0,0,-194,0,0,0,-194,0,-194,0,-194,0,0,0,0, // State 517 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,0,0,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-138,0, // State 518 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 519 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-59,0,0,0,0,0,-59,0,0,-59,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-59,0, // State 520 0,0,0,0,0,0,0,0,0,-457,-457,558,0,0,0,-457,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 521 0,0,0,0,0,0,0,0,0,0,559,0,0,0,0,0,0,0,0,0,0,0,0,-167,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 522 0,0,0,0,0,0,0,0,0,-459,-459,0,0,0,0,-459,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 523 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 524 0,0,0,-83,0,-83,-83,0,0,0,0,0,0,0,-83,0,0,0,0,0,0,0,0,-83,0,0,0,0,0,-83,-83,-83,0,0,0,0,0,0,0,0,0,0,-83,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 525 0,0,0,0,0,0,0,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 526 0,0,0,0,0,0,0,0,0,0,-409,0,0,0,37,-409,0,0,0,0,0,0,0,0,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,268,0,0,0,0,0,0,0,0,0,0,0, // State 527 -425,0,0,-425,0,0,-425,-425,0,0,-425,0,0,0,0,-425,-425,0,0,-425,-425,-425,-425,-425,0,-425,-425,0,-425,-425,0,-425,-425,0,0,0,0,0,-425,0,0,0,0,0,0,0,0,0,-425,0,0,0,0,0,0,0,-425,0, // State 528 0,0,0,0,0,0,0,-485,0,-485,-485,0,0,-485,0,-485,0,-485,0,0,0,0,0,-485,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-485,0,0, // State 529 0,0,0,45,0,46,47,-174,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 530 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 531 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 532 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 533 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 534 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 535 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 536 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 537 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-125,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 538 91,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,93,0,0,443,444,445,446,0,0,94,95,0,96,97,0,98,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,447,0,0,0,0,0,0,448,0,0, // State 539 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-64,0,0,0,0,0,-64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 540 0,0,0,-374,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-374,-374,0,-374,0,0,0,0,0,0,0,0,0,0,0,0,0,-374,0,0,0,-374,0,-374,0,-374,0,0,0,0, // State 541 0,0,0,0,0,0,0,0,0,0,-109,0,0,0,0,-109,0,0,0,443,444,445,446,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-109,0, // State 542 0,0,0,0,0,0,0,0,0,0,-112,0,0,0,0,-112,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-112,0, // State 543 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 544 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-183,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 545 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-185,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 546 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-182,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 547 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-184,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 548 0,0,0,0,0,0,0,0,0,0,568,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-135,0, // State 549 -23,0,0,0,0,0,-23,0,0,0,0,0,0,0,0,0,-23,0,0,-23,-23,-23,-23,0,0,-23,-23,0,-23,-23,0,-23,-23,0,0,0,0,0,-23,0,0,0,0,0,0,0,0,0,-23,0,0,0,0,0,0,0,-23,0, // State 550 0,0,0,-118,0,0,0,0,0,0,0,0,0,0,0,569,0,0,0,0,0,0,0,0,0,0,0,0,-118,-118,0,-118,0,0,0,0,0,0,0,0,0,0,0,0,0,-118,0,0,0,-118,0,-118,0,-118,0,0,0,0, // State 551 0,0,0,-196,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-196,-196,0,-196,0,0,0,0,0,0,0,0,0,0,0,0,0,-196,0,0,0,-196,0,-196,0,-196,0,0,0,0, // State 552 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,0,0,28,0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-140,0, // State 553 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,571,0, // State 554 0,0,0,0,0,0,0,0,0,0,572,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-137,0, // State 555 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,573,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 556 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,574,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 557 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 558 0,0,0,-84,0,-84,-84,0,0,0,0,0,0,0,-84,0,0,0,0,0,0,0,0,-84,0,0,0,0,0,-84,-84,-84,0,0,0,0,0,0,0,0,0,0,-84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 559 0,0,0,0,0,0,0,0,0,0,-466,0,0,0,0,0,0,0,0,0,0,0,0,-466,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 560 0,0,0,0,0,0,576,0,0,-460,-460,0,0,0,0,-460,577,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 561 0,0,0,0,0,0,0,0,0,0,-350,0,0,0,0,-350,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 562 0,0,0,0,0,0,0,578,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 563 0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-501,-501,0,-501,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0,0,144,0,145,0,18,0,0,0,0, // State 564 0,0,0,-375,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-375,-375,0,-375,0,0,0,0,0,0,0,0,0,0,0,0,0,-375,0,0,0,-375,0,-375,0,-375,0,0,0,0, // State 565 0,0,0,0,0,0,0,0,0,0,-108,0,0,0,0,-108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-108,0, // State 566 0,0,0,0,0,0,0,0,0,0,-181,0,0,0,0,-181,0,0,0,-181,-181,-181,-181,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-181,0, // State 567 -24,0,0,0,0,0,-24,0,0,0,0,0,0,0,0,0,-24,0,0,-24,-24,-24,-24,0,0,-24,-24,0,-24,-24,0,-24,-24,0,0,0,0,0,-24,0,0,0,0,0,0,0,0,0,-24,0,0,0,0,0,0,0,-24,0, // State 568 0,0,0,-117,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-117,-117,0,-117,0,0,0,0,0,0,0,0,0,0,0,0,0,-117,0,0,0,-117,0,-117,0,-117,0,0,0,0, // State 569 0,0,0,0,0,0,0,0,0,0,579,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-139,0, // State 570 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-189,0,0,0,-189,0, // State 571 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-28,0,0,-28,0,0,0,0,0,-28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-28,0, // State 572 0,0,0,0,0,0,0,0,0,0,-186,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-186,0, // State 573 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-128,0,0,0,0,0,0,0,-128,0,0,0,-128,0, // State 574 0,0,0,0,0,0,0,0,0,-455,-455,0,0,0,0,-455,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 575 0,0,0,45,0,46,47,-174,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 576 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,-166,0,0,0,0,0,40,71,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 577 0,0,0,0,0,0,0,-486,0,-486,-486,582,0,-486,0,-486,0,-486,0,0,0,0,0,-486,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-486,0,0, // State 578 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-29,0,0,-29,0,0,0,0,0,-29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-29,0, // State 579 0,0,0,0,0,0,0,583,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 580 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,584,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 581 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 582 0,0,0,0,0,0,0,0,0,-456,-456,586,0,0,0,-456,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 583 0,0,0,0,0,0,0,0,0,-458,-458,0,0,0,0,-458,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 584 0,0,0,0,0,0,0,-484,0,-484,-484,0,0,-484,0,-484,0,-484,0,0,0,0,0,-484,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-484,0,0, // State 585 0,0,0,45,0,46,47,0,0,0,0,0,0,0,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,41,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 586 0,0,0,0,0,0,0,0,0,-454,-454,0,0,0,0,-454,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, ]; const ___EOF_ACTION: &'static [i16] = &[ // State 0 0, // State 1 -502, // State 2 0, // State 3 0, // State 4 0, // State 5 0, // State 6 0, // State 7 0, // State 8 0, // State 9 -448, // State 10 0, // State 11 0, // State 12 0, // State 13 0, // State 14 0, // State 15 0, // State 16 0, // State 17 0, // State 18 -452, // State 19 -146, // State 20 -450, // State 21 -414, // State 22 -446, // State 23 -413, // State 24 -412, // State 25 -369, // State 26 -447, // State 27 -415, // State 28 -424, // State 29 0, // State 30 -386, // State 31 -403, // State 32 -449, // State 33 -388, // State 34 0, // State 35 -399, // State 36 0, // State 37 0, // State 38 -402, // State 39 -357, // State 40 -358, // State 41 -398, // State 42 -481, // State 43 -451, // State 44 0, // State 45 0, // State 46 0, // State 47 0, // State 48 0, // State 49 0, // State 50 0, // State 51 0, // State 52 0, // State 53 0, // State 54 0, // State 55 0, // State 56 0, // State 57 0, // State 58 0, // State 59 0, // State 60 0, // State 61 0, // State 62 -232, // State 63 0, // State 64 -494, // State 65 -148, // State 66 -354, // State 67 -145, // State 68 0, // State 69 0, // State 70 -359, // State 71 0, // State 72 -387, // State 73 0, // State 74 0, // State 75 0, // State 76 0, // State 77 0, // State 78 0, // State 79 0, // State 80 -384, // State 81 0, // State 82 0, // State 83 0, // State 84 0, // State 85 0, // State 86 0, // State 87 0, // State 88 0, // State 89 0, // State 90 0, // State 91 0, // State 92 0, // State 93 0, // State 94 0, // State 95 0, // State 96 0, // State 97 0, // State 98 0, // State 99 -479, // State 100 0, // State 101 0, // State 102 0, // State 103 0, // State 104 -483, // State 105 0, // State 106 0, // State 107 0, // State 108 0, // State 109 -296, // State 110 0, // State 111 0, // State 112 0, // State 113 0, // State 114 0, // State 115 0, // State 116 -234, // State 117 0, // State 118 0, // State 119 0, // State 120 0, // State 121 -233, // State 122 0, // State 123 0, // State 124 -216, // State 125 0, // State 126 0, // State 127 -224, // State 128 -228, // State 129 0, // State 130 0, // State 131 0, // State 132 0, // State 133 0, // State 134 -334, // State 135 -338, // State 136 -264, // State 137 -333, // State 138 -371, // State 139 -335, // State 140 -332, // State 141 0, // State 142 0, // State 143 0, // State 144 0, // State 145 0, // State 146 0, // State 147 0, // State 148 0, // State 149 0, // State 150 -147, // State 151 -43, // State 152 -405, // State 153 -409, // State 154 0, // State 155 0, // State 156 0, // State 157 0, // State 158 0, // State 159 0, // State 160 0, // State 161 -393, // State 162 0, // State 163 -401, // State 164 0, // State 165 -385, // State 166 -400, // State 167 0, // State 168 0, // State 169 0, // State 170 0, // State 171 0, // State 172 0, // State 173 -475, // State 174 0, // State 175 0, // State 176 0, // State 177 0, // State 178 0, // State 179 0, // State 180 0, // State 181 0, // State 182 0, // State 183 0, // State 184 0, // State 185 0, // State 186 -478, // State 187 0, // State 188 -477, // State 189 0, // State 190 -474, // State 191 0, // State 192 0, // State 193 0, // State 194 0, // State 195 0, // State 196 -280, // State 197 0, // State 198 0, // State 199 -288, // State 200 -292, // State 201 -328, // State 202 0, // State 203 0, // State 204 0, // State 205 -298, // State 206 0, // State 207 0, // State 208 0, // State 209 0, // State 210 -235, // State 211 0, // State 212 -218, // State 213 0, // State 214 0, // State 215 -226, // State 216 -230, // State 217 -266, // State 218 0, // State 219 0, // State 220 0, // State 221 -297, // State 222 0, // State 223 -217, // State 224 0, // State 225 0, // State 226 -225, // State 227 -229, // State 228 -265, // State 229 0, // State 230 0, // State 231 0, // State 232 -212, // State 233 -248, // State 234 0, // State 235 -208, // State 236 -220, // State 237 -256, // State 238 -260, // State 239 0, // State 240 0, // State 241 0, // State 242 0, // State 243 0, // State 244 -339, // State 245 0, // State 246 0, // State 247 0, // State 248 0, // State 249 0, // State 250 0, // State 251 0, // State 252 0, // State 253 0, // State 254 0, // State 255 0, // State 256 0, // State 257 -44, // State 258 -407, // State 259 -404, // State 260 -349, // State 261 -411, // State 262 -453, // State 263 -461, // State 264 -469, // State 265 -408, // State 266 -351, // State 267 0, // State 268 0, // State 269 -391, // State 270 0, // State 271 0, // State 272 -395, // State 273 0, // State 274 -392, // State 275 0, // State 276 -396, // State 277 0, // State 278 0, // State 279 -480, // State 280 0, // State 281 0, // State 282 0, // State 283 0, // State 284 0, // State 285 0, // State 286 0, // State 287 0, // State 288 0, // State 289 -476, // State 290 0, // State 291 0, // State 292 0, // State 293 0, // State 294 -276, // State 295 -312, // State 296 0, // State 297 -272, // State 298 -284, // State 299 -320, // State 300 -324, // State 301 0, // State 302 -282, // State 303 0, // State 304 0, // State 305 -290, // State 306 -294, // State 307 -330, // State 308 0, // State 309 0, // State 310 0, // State 311 -299, // State 312 0, // State 313 -219, // State 314 0, // State 315 0, // State 316 -227, // State 317 -231, // State 318 -267, // State 319 -214, // State 320 -250, // State 321 0, // State 322 -210, // State 323 -222, // State 324 -258, // State 325 -262, // State 326 0, // State 327 -281, // State 328 0, // State 329 0, // State 330 -289, // State 331 -293, // State 332 -329, // State 333 -213, // State 334 -249, // State 335 0, // State 336 -209, // State 337 -221, // State 338 -257, // State 339 -261, // State 340 0, // State 341 0, // State 342 -244, // State 343 -204, // State 344 -240, // State 345 -252, // State 346 0, // State 347 0, // State 348 0, // State 349 0, // State 350 0, // State 351 0, // State 352 0, // State 353 0, // State 354 0, // State 355 0, // State 356 0, // State 357 0, // State 358 -197, // State 359 0, // State 360 0, // State 361 0, // State 362 0, // State 363 0, // State 364 0, // State 365 0, // State 366 0, // State 367 0, // State 368 -406, // State 369 -53, // State 370 -410, // State 371 0, // State 372 0, // State 373 -78, // State 374 0, // State 375 0, // State 376 0, // State 377 -394, // State 378 -397, // State 379 0, // State 380 0, // State 381 0, // State 382 0, // State 383 0, // State 384 0, // State 385 0, // State 386 -487, // State 387 -482, // State 388 0, // State 389 -308, // State 390 -268, // State 391 -304, // State 392 -316, // State 393 -278, // State 394 -314, // State 395 0, // State 396 -274, // State 397 -286, // State 398 -322, // State 399 -326, // State 400 0, // State 401 -283, // State 402 0, // State 403 0, // State 404 -291, // State 405 -295, // State 406 -331, // State 407 -215, // State 408 -251, // State 409 0, // State 410 -211, // State 411 -223, // State 412 -259, // State 413 -263, // State 414 -246, // State 415 -206, // State 416 -242, // State 417 -254, // State 418 -277, // State 419 -313, // State 420 0, // State 421 -273, // State 422 -285, // State 423 -321, // State 424 -325, // State 425 -245, // State 426 -205, // State 427 -241, // State 428 -253, // State 429 0, // State 430 -236, // State 431 0, // State 432 0, // State 433 0, // State 434 0, // State 435 0, // State 436 0, // State 437 0, // State 438 0, // State 439 0, // State 440 -376, // State 441 0, // State 442 0, // State 443 0, // State 444 0, // State 445 0, // State 446 0, // State 447 0, // State 448 0, // State 449 0, // State 450 -198, // State 451 0, // State 452 -193, // State 453 0, // State 454 0, // State 455 0, // State 456 -373, // State 457 0, // State 458 0, // State 459 0, // State 460 -54, // State 461 -79, // State 462 0, // State 463 0, // State 464 0, // State 465 0, // State 466 0, // State 467 0, // State 468 0, // State 469 0, // State 470 0, // State 471 0, // State 472 0, // State 473 0, // State 474 0, // State 475 0, // State 476 -300, // State 477 -310, // State 478 -270, // State 479 -306, // State 480 -318, // State 481 -279, // State 482 -315, // State 483 0, // State 484 -275, // State 485 -287, // State 486 -323, // State 487 -327, // State 488 -247, // State 489 -207, // State 490 -243, // State 491 -255, // State 492 -238, // State 493 -309, // State 494 -269, // State 495 -305, // State 496 -317, // State 497 -237, // State 498 0, // State 499 0, // State 500 -377, // State 501 -372, // State 502 0, // State 503 0, // State 504 0, // State 505 0, // State 506 -116, // State 507 0, // State 508 0, // State 509 0, // State 510 0, // State 511 0, // State 512 0, // State 513 0, // State 514 0, // State 515 -195, // State 516 -194, // State 517 0, // State 518 0, // State 519 0, // State 520 -457, // State 521 0, // State 522 -459, // State 523 0, // State 524 0, // State 525 0, // State 526 -409, // State 527 0, // State 528 -485, // State 529 0, // State 530 -302, // State 531 -311, // State 532 -271, // State 533 -307, // State 534 -319, // State 535 -239, // State 536 -301, // State 537 0, // State 538 0, // State 539 0, // State 540 -374, // State 541 0, // State 542 0, // State 543 0, // State 544 0, // State 545 0, // State 546 0, // State 547 0, // State 548 0, // State 549 0, // State 550 -118, // State 551 -196, // State 552 0, // State 553 0, // State 554 0, // State 555 0, // State 556 0, // State 557 0, // State 558 0, // State 559 0, // State 560 -460, // State 561 -350, // State 562 0, // State 563 -303, // State 564 -375, // State 565 0, // State 566 0, // State 567 0, // State 568 -117, // State 569 0, // State 570 0, // State 571 0, // State 572 0, // State 573 0, // State 574 -455, // State 575 0, // State 576 0, // State 577 -486, // State 578 0, // State 579 0, // State 580 0, // State 581 0, // State 582 -456, // State 583 -458, // State 584 -484, // State 585 0, // State 586 -454, ]; const ___GOTO: &'static [i16] = &[ // State 0 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 1 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 2 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,0,14,0,0, // State 3 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 4 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,21,0,0,0,0,0,0,0,0,0,0,0,0,0,22,23,24,0,0,0,0,25,0,0,0,0,0,0,0,26,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 5 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 6 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,44,0,0,0,0,0,0,0,0, // State 7 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 8 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,49,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 9 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 10 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 11 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,51,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,52,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,0,53,0,0, // State 12 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 13 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,55,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,56,0,0,0,0, // State 14 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 15 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,59,0,60,0,0,0,61,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 17 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 18 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 19 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,66,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,68,0,0,0,31,69,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,70,0,0,0,0,0,0,0,0, // State 20 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 21 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 22 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 23 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 24 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 25 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 26 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 27 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 28 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 29 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,73,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 30 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 31 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 32 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 33 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 34 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,77,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,79,0,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 35 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 36 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,81,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 37 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,82,0,0,0,0,0,0,0,0, // State 38 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 39 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 40 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 41 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 42 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 43 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 44 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,87,0,0,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 45 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,99,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,100,0,0,0,0,0,0,0,0, // State 46 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,103,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,104,0,0,0,0,0,0,0,0, // State 47 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,105,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 48 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 49 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,107,0,108,0,0,0,109,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 50 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,49,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 51 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 52 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,112,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,56,0,0,0,0, // State 53 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,114,0,115,0,0,0,116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 54 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,49,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 55 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 56 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,119,0,120,0,0,0,121,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 57 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 58 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,124,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 59 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 60 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 61 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,131,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,132,0,0,0,0,0,0,0,0,0,133,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 62 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,137,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 63 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,146,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,147,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,148,149,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,150,0,0,0,0,0,0,0,0,0,0, // State 64 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 65 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,151,0,0,0,31,69,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,70,0,0,0,0,0,0,0,0, // State 66 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 67 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 68 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 69 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 70 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 71 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 72 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 73 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 74 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,77,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,157,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,79,0,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 75 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,158,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,159,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 76 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,163,0,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 77 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 78 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 79 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,166,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 80 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 81 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 82 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,168,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,169,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,170,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,171,0,172,0,0,0,0,0,0, // State 83 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 84 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 85 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 86 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 87 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,175,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 88 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 89 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 90 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 91 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,179,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,180,0,181,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 92 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,182,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,0,0,0,183,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 93 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 94 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 95 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 96 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 97 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 98 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,187,0,0,0,0,0,0,0,0, // State 99 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 100 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,189,0,0,0,0,0,0,0,0, // State 101 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,190,0,0,0,0,0,0,0,0, // State 102 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 103 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 104 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 105 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 106 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,196,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 107 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,198,0,0,0,0,0,199,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 108 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 109 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,202,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 110 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,203,0,204,0,0,0,205,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 111 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,49,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 112 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,208,0,209,0,0,0,210,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 113 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,212,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 114 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,214,0,0,0,0,0,215,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 115 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 116 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,218,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 117 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,219,0,220,0,0,0,221,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 118 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 119 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,225,0,0,0,0,0,226,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 120 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 121 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,229,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 122 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,230,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 123 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 124 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,234,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 125 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,235,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 126 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 127 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,238,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 128 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,239,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 129 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,133,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 130 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 131 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 132 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 133 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,49,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,244,0, // State 134 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 135 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 136 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 137 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 138 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 139 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 140 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 141 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,247,0,0,0,0,0,0,0,0,248,249,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 142 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 143 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 144 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 145 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,148,149,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,0,0,0,0,0,0,0,0,0,0, // State 146 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 147 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 148 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 149 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 150 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 151 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 152 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,259,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,260,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,261,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 153 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,262,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,263,0,0,0,0,0,0,0,0,0,0,0,0,0,264,0,0,0,0,265,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,266,0,0,0,267,0,0,0,0,0,0,0,0,0,0,0, // State 154 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,146,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,269,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,148,149,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,150,0,0,0,0,0,0,0,0,0,0, // State 155 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 156 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 157 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,271,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 158 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 159 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 160 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 161 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 162 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 163 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 164 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 165 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 166 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 167 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,170,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,171,0,279,0,0,0,0,0,0, // State 168 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 169 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 170 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 171 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 172 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,282,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,283,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,284,0,0,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 173 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 174 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 175 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 176 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 177 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 178 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 179 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 180 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,286,0,0,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 181 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 182 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,175,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 183 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 184 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 185 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,289,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 186 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 187 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,290,0,0,0,0,0,0,0,0, // State 188 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 189 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 190 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 191 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 192 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,292,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,104,0,0,0,0,0,0,0,0, // State 193 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,168,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,293,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,170,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,171,0,172,0,0,0,0,0,0, // State 194 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,146,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,294,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,148,149,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,150,0,0,0,0,0,0,0,0,0,0, // State 195 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 196 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,296,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 197 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,297,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 198 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 199 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,300,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 200 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,301,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 201 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 202 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,302,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 203 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,304,0,0,0,0,0,305,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 204 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 205 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,308,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 206 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,309,0,310,0,0,0,311,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 207 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,313,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 208 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,315,0,0,0,0,0,316,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 209 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 210 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,319,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 211 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 212 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,321,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 213 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,322,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 214 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 215 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,325,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 216 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,326,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 217 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 218 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,327,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 219 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,329,0,0,0,0,0,330,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 220 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 221 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,333,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 222 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 223 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,335,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 224 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,336,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 225 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 226 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,339,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 227 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,340,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 228 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 229 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 230 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,342,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 231 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 232 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,343,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 233 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 234 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 235 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,345,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 236 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,346,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 237 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 238 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 239 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 240 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 241 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 242 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,348,0,0,0,0,0,0,0,0, // State 243 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,247,0,0,0,0,0,0,0,0,349,249,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 244 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 245 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 246 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 247 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 248 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 249 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 250 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 251 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,354,0,355,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,356,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 252 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,360,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,361,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,362,363,0,0,364,0,0,0,0,0,0,0,0,0,0,0,0,365,0,24,0,0,0,0,25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 253 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,367,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 254 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 255 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 256 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 257 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 258 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,369,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 259 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 260 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 261 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,263,0,0,0,0,0,0,0,0,0,0,0,0,0,264,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,371,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 262 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 263 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 264 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 265 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 266 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 267 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 268 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 269 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 270 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 271 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 272 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 273 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 274 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 275 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,380,0,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 276 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 277 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 278 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 279 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 280 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 281 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,382,0,0,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 282 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 283 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 284 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 285 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 286 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,0,0,0,385,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 287 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 288 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 289 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 290 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 291 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 292 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 293 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 294 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,390,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 295 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 296 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 297 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,392,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 298 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,393,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 299 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 300 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 301 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 302 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,395,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 303 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,396,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 304 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 305 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,399,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 306 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,400,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 307 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 308 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,401,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 309 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,403,0,0,0,0,0,404,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 310 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 311 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,407,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 312 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 313 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,409,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 314 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,410,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 315 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 316 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,413,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 317 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,414,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 318 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 319 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,415,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 320 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 321 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 322 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,417,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 323 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,418,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 324 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 325 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 326 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 327 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,420,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 328 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,421,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 329 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 330 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,424,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 331 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,425,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 332 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 333 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,426,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 334 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 335 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 336 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,428,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 337 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,429,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 338 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 339 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 340 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 341 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 342 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 343 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,431,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 344 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 345 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 346 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 347 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 348 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 349 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,360,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,361,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,434,363,0,0,364,0,0,0,0,0,0,0,0,0,0,0,0,365,0,24,0,0,0,0,25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 350 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,435,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,436,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,437,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 351 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,438,0,0,0,0,0,0,0,0, // State 352 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,439,0,440,0,441,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,180,0,442,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 353 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 354 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,449,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,450,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 355 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,354,0,452,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 356 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,454,0,0,0,0,0,0,0,0, // State 357 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,455,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 358 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 359 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,456,0,0,364,0,0,0,0,0,0,0,0,0,0,0,0,365,0,24,0,0,0,0,25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 360 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 361 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 362 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 363 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 364 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 365 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 366 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 367 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 368 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 369 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 370 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 371 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,463,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,104,0,0,0,0,0,0,0,0, // State 372 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,464,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,465,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,466,467,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,468,0,0,0,0,469,0,0,0,0,0,0,0,0, // State 373 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 374 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,146,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,470,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,148,149,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,150,0,0,0,0,0,0,0,0,0,0, // State 375 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,471,0,0,0,0,0,0,0,0, // State 376 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 377 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 378 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 379 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 380 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 381 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 382 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 383 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 384 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,175,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 385 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,0,0,0,474,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 386 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 387 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 388 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,476,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 389 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 390 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,477,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 391 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 392 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 393 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,478,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 394 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 395 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 396 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,480,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 397 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,481,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 398 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 399 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 400 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 401 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,483,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 402 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,484,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 403 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 404 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,487,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 405 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,488,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 406 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 407 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,489,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 408 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 409 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 410 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,491,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 411 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,492,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 412 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 413 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 414 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 415 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,493,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 416 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 417 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 418 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,494,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 419 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 420 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 421 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,496,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 422 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,497,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 423 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 424 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 425 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 426 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,498,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 427 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 428 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 429 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 430 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 431 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,500,0,0,0,0,0,0,0,0, // State 432 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,439,0,440,0,501,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,180,0,442,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 433 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 434 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,503,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 435 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 436 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 437 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 438 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 439 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 440 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 441 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,508,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,286,0,0,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 442 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 443 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 444 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 445 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 446 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,510,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,511,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 447 0,0,0,0,0,0,0,0,0,0,0,0,0,0,512,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,439,0,513,0,0,0,0,0,0,0,0,0,0,514,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,180,0,442,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 448 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 449 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,354,0,515,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 450 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 451 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,449,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 452 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 453 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 454 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 455 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 456 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 457 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 458 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 459 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 460 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 461 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 462 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 463 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,466,467,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,522,0,0,0,0,469,0,0,0,0,0,0,0,0, // State 464 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 465 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 466 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 467 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 468 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 469 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 470 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 471 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 472 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 473 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,175,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 474 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,529,0,0,0,0,0,0,0,0, // State 475 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 476 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 477 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 478 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,531,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 479 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 480 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 481 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,532,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 482 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 483 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 484 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,534,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 485 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,535,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 486 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 487 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 488 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 489 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,536,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 490 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 491 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 492 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 493 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 494 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,537,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 495 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 496 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 497 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 498 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 499 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 500 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 501 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 502 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 503 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 504 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 505 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,439,0,440,0,541,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,180,0,442,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 506 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 507 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 508 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,542,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,511,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 509 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,543,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 510 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,544,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 511 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,439,0,549,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,180,0,442,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 512 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 513 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 514 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,449,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 515 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 516 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 517 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,553,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,554,0,0,0,0,0,0,0,0,0,0,0,0,555,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,23,24,0,0,0,0,25,0,0,0,0,0,0,0,556,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 518 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,557,0,0,0,0,0,0,0,0, // State 519 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 520 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 521 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 522 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 523 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,560,0,0,0,0,0,0,0,0, // State 524 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 525 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,561,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 526 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,262,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,263,0,0,0,0,0,0,0,0,0,0,0,0,0,264,0,0,0,0,265,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,266,0,0,0,562,0,0,0,0,0,0,0,0,0,0,0, // State 527 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 528 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 529 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,563,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,104,0,0,0,0,0,0,0,0, // State 530 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 531 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 532 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,136,0,564,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 533 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 534 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 535 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 536 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 537 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 538 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,439,0,440,0,565,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,86,24,0,0,0,0,25,180,0,442,88,89,0,90,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 539 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 540 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 541 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,566,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 542 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 543 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,567,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 544 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 545 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 546 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 547 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 548 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 549 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 550 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 551 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 552 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,570,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,23,24,0,0,0,0,25,0,0,0,0,0,0,0,556,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 553 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 554 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 555 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 556 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 557 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,575,0,0,0,0,0,0,0,0, // State 558 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 559 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 560 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 561 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 562 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 563 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,134,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,135,0,0,0,0,245,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,138,139,140,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,0,0,142,0, // State 564 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 565 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 566 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 567 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 568 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 569 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 570 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 571 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 572 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 573 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 574 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 575 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,580,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,104,0,0,0,0,0,0,0,0, // State 576 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,464,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,581,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,466,467,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,468,0,0,0,0,469,0,0,0,0,0,0,0,0, // State 577 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 578 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 579 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 580 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 581 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,585,0,0,0,0,0,0,0,0, // State 582 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 583 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 584 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // State 585 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,587,0,0,0,0,0,0,0,0, // State 586 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, ]; fn ___expected_tokens(___state: usize) -> Vec<::std::string::String> { const ___TERMINAL: &'static [&'static str] = &[ r###""!""###, r###""!=""###, r###""!~""###, r###""#""###, r###""#![...]""###, r###""&""###, r###""(""###, r###"")""###, r###""*""###, r###""+""###, r###"",""###, r###""->""###, r###""..""###, r###"":""###, r###""::""###, r###"";""###, r###""<""###, r###""=""###, r###""==""###, r###""=>""###, r###""=>?""###, r###""=>@L""###, r###""=>@R""###, r###"">""###, r###""?""###, r###""@L""###, r###""@R""###, r###""CharLiteral""###, r###""Escape""###, r###""Id""###, r###""Lifetime""###, r###""MacroId""###, r###""RegexLiteral""###, r###""StartGrammar""###, r###""StartGrammarWhereClauses""###, r###""StartMatchMapping""###, r###""StartPattern""###, r###""StartTypeRef""###, r###""StringLiteral""###, r###""[""###, r###""]""###, r###""_""###, r###""dyn""###, r###""else""###, r###""enum""###, r###""extern""###, r###""for""###, r###""grammar""###, r###""if""###, r###""match""###, r###""mut""###, r###""pub""###, r###""type""###, r###""use""###, r###""where""###, r###""{""###, r###""}""###, r###""~~""###, ]; ___ACTION[(___state * 58)..].iter().zip(___TERMINAL).filter_map(|(&state, terminal)| { if state == 0 { None } else { Some(terminal.to_string()) } }).collect() } pub struct ___StateMachine<'input> where { text: &'input str, ___phantom: ::std::marker::PhantomData<(&'input ())>, } impl<'input> ___state_machine::ParserDefinition for ___StateMachine<'input> where { type Location = usize; type Error = tok::Error; type Token = Tok<'input>; type TokenIndex = usize; type Symbol = ___Symbol<'input>; type Success = Top; type StateIndex = i16; type Action = i16; type ReduceIndex = i16; type NonterminalIndex = usize; #[inline] fn start_location(&self) -> Self::Location { Default::default() } #[inline] fn start_state(&self) -> Self::StateIndex { 0 } #[inline] fn token_to_index(&self, token: &Self::Token) -> Option { ___token_to_integer(token, ::std::marker::PhantomData::<(&())>) } #[inline] fn action(&self, state: i16, integer: usize) -> i16 { ___ACTION[(state as usize) * 58 + integer] } #[inline] fn error_action(&self, state: i16) -> i16 { ___ACTION[(state as usize) * 58 + (58 - 1)] } #[inline] fn eof_action(&self, state: i16) -> i16 { ___EOF_ACTION[state as usize] } #[inline] fn goto(&self, state: i16, nt: usize) -> i16 { ___GOTO[(state as usize) * 166 + nt] - 1 } fn token_to_symbol(&self, token_index: usize, token: Self::Token) -> Self::Symbol { ___token_to_symbol(token_index, token, ::std::marker::PhantomData::<(&())>) } fn expected_tokens(&self, state: i16) -> Vec { ___expected_tokens(state as usize) } #[inline] fn uses_error_recovery(&self) -> bool { false } #[inline] fn error_recovery_symbol( &self, recovery: ___state_machine::ErrorRecovery, ) -> Self::Symbol { panic!("error recovery not enabled for this grammar") } fn reduce( &mut self, action: i16, start_location: Option<&Self::Location>, states: &mut Vec, symbols: &mut Vec<___state_machine::SymbolTriple>, ) -> Option<___state_machine::ParseResult> { ___reduce( self.text, action, start_location, states, symbols, ::std::marker::PhantomData::<(&())>, ) } fn simulate_reduce(&self, action: i16) -> ___state_machine::SimulatedReduce { ___simulate_reduce(action, ::std::marker::PhantomData::<(&())>) } } fn ___token_to_integer< 'input, >( ___token: &Tok<'input>, _: ::std::marker::PhantomData<(&'input ())>, ) -> Option { match *___token { Tok::Bang if true => Some(0), Tok::BangEquals if true => Some(1), Tok::BangTilde if true => Some(2), Tok::Hash if true => Some(3), Tok::ShebangAttribute(_) if true => Some(4), Tok::Ampersand if true => Some(5), Tok::LeftParen if true => Some(6), Tok::RightParen if true => Some(7), Tok::Star if true => Some(8), Tok::Plus if true => Some(9), Tok::Comma if true => Some(10), Tok::MinusGreaterThan if true => Some(11), Tok::DotDot if true => Some(12), Tok::Colon if true => Some(13), Tok::ColonColon if true => Some(14), Tok::Semi if true => Some(15), Tok::LessThan if true => Some(16), Tok::Equals if true => Some(17), Tok::EqualsEquals if true => Some(18), Tok::EqualsGreaterThanCode(_) if true => Some(19), Tok::EqualsGreaterThanQuestionCode(_) if true => Some(20), Tok::EqualsGreaterThanLookahead if true => Some(21), Tok::EqualsGreaterThanLookbehind if true => Some(22), Tok::GreaterThan if true => Some(23), Tok::Question if true => Some(24), Tok::Lookahead if true => Some(25), Tok::Lookbehind if true => Some(26), Tok::CharLiteral(_) if true => Some(27), Tok::Escape(_) if true => Some(28), Tok::Id(_) if true => Some(29), Tok::Lifetime(_) if true => Some(30), Tok::MacroId(_) if true => Some(31), Tok::RegexLiteral(_) if true => Some(32), Tok::StartGrammar if true => Some(33), Tok::StartGrammarWhereClauses if true => Some(34), Tok::StartMatchMapping if true => Some(35), Tok::StartPattern if true => Some(36), Tok::StartTypeRef if true => Some(37), Tok::StringLiteral(_) if true => Some(38), Tok::LeftBracket if true => Some(39), Tok::RightBracket if true => Some(40), Tok::Underscore if true => Some(41), Tok::Dyn if true => Some(42), Tok::Else if true => Some(43), Tok::Enum if true => Some(44), Tok::Extern if true => Some(45), Tok::For if true => Some(46), Tok::Grammar if true => Some(47), Tok::If if true => Some(48), Tok::Match if true => Some(49), Tok::Mut if true => Some(50), Tok::Pub if true => Some(51), Tok::Type if true => Some(52), Tok::Use(_) if true => Some(53), Tok::Where if true => Some(54), Tok::LeftBrace if true => Some(55), Tok::RightBrace if true => Some(56), Tok::TildeTilde if true => Some(57), _ => None, } } fn ___token_to_symbol< 'input, >( ___token_index: usize, ___token: Tok<'input>, _: ::std::marker::PhantomData<(&'input ())>, ) -> ___Symbol<'input> { match ___token_index { 0 => match ___token { ___tok @ Tok::Bang => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 1 => match ___token { ___tok @ Tok::BangEquals => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 2 => match ___token { ___tok @ Tok::BangTilde => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 3 => match ___token { ___tok @ Tok::Hash => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 4 => match ___token { Tok::ShebangAttribute(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 5 => match ___token { ___tok @ Tok::Ampersand => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 6 => match ___token { ___tok @ Tok::LeftParen => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 7 => match ___token { ___tok @ Tok::RightParen => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 8 => match ___token { ___tok @ Tok::Star => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 9 => match ___token { ___tok @ Tok::Plus => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 10 => match ___token { ___tok @ Tok::Comma => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 11 => match ___token { ___tok @ Tok::MinusGreaterThan => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 12 => match ___token { ___tok @ Tok::DotDot => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 13 => match ___token { ___tok @ Tok::Colon => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 14 => match ___token { ___tok @ Tok::ColonColon => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 15 => match ___token { ___tok @ Tok::Semi => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 16 => match ___token { ___tok @ Tok::LessThan => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 17 => match ___token { ___tok @ Tok::Equals => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 18 => match ___token { ___tok @ Tok::EqualsEquals => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 19 => match ___token { Tok::EqualsGreaterThanCode(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 20 => match ___token { Tok::EqualsGreaterThanQuestionCode(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 21 => match ___token { ___tok @ Tok::EqualsGreaterThanLookahead => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 22 => match ___token { ___tok @ Tok::EqualsGreaterThanLookbehind => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 23 => match ___token { ___tok @ Tok::GreaterThan => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 24 => match ___token { ___tok @ Tok::Question => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 25 => match ___token { ___tok @ Tok::Lookahead => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 26 => match ___token { ___tok @ Tok::Lookbehind => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 27 => match ___token { Tok::CharLiteral(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 28 => match ___token { Tok::Escape(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 29 => match ___token { Tok::Id(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 30 => match ___token { Tok::Lifetime(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 31 => match ___token { Tok::MacroId(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 32 => match ___token { Tok::RegexLiteral(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 33 => match ___token { ___tok @ Tok::StartGrammar => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 34 => match ___token { ___tok @ Tok::StartGrammarWhereClauses => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 35 => match ___token { ___tok @ Tok::StartMatchMapping => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 36 => match ___token { ___tok @ Tok::StartPattern => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 37 => match ___token { ___tok @ Tok::StartTypeRef => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 38 => match ___token { Tok::StringLiteral(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 39 => match ___token { ___tok @ Tok::LeftBracket => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 40 => match ___token { ___tok @ Tok::RightBracket => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 41 => match ___token { ___tok @ Tok::Underscore => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 42 => match ___token { ___tok @ Tok::Dyn => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 43 => match ___token { ___tok @ Tok::Else => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 44 => match ___token { ___tok @ Tok::Enum => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 45 => match ___token { ___tok @ Tok::Extern => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 46 => match ___token { ___tok @ Tok::For => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 47 => match ___token { ___tok @ Tok::Grammar => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 48 => match ___token { ___tok @ Tok::If => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 49 => match ___token { ___tok @ Tok::Match => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 50 => match ___token { ___tok @ Tok::Mut => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 51 => match ___token { ___tok @ Tok::Pub => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 52 => match ___token { ___tok @ Tok::Type => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 53 => match ___token { Tok::Use(___tok0) => ___Symbol::Variant1((___tok0)), _ => unreachable!(), }, 54 => match ___token { ___tok @ Tok::Where => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 55 => match ___token { ___tok @ Tok::LeftBrace => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 56 => match ___token { ___tok @ Tok::RightBrace => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, 57 => match ___token { ___tok @ Tok::TildeTilde => ___Symbol::Variant0((___tok)), _ => unreachable!(), }, _ => unreachable!(), } } fn ___simulate_reduce< 'input, >( ___reduce_index: i16, _: ::std::marker::PhantomData<(&'input ())>, ) -> ___state_machine::SimulatedReduce<___StateMachine<'input>> { match ___reduce_index { 0 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 0, } } 1 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 0, } } 2 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 1, } } 3 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 1, } } 4 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 2, } } 5 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 2, } } 6 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 3, } } 7 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 4, } } 8 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 4, } } 9 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 5, } } 10 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 6, } } 11 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 6, } } 12 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 7, } } 13 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 8, } } 14 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 8, } } 15 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 9, } } 16 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 10, } } 17 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 10, } } 18 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 11, } } 19 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 12, } } 20 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 13, } } 21 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 13, } } 22 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 14, } } 23 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 14, } } 24 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 15, } } 25 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 16, } } 26 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 16, } } 27 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 17, } } 28 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 17, } } 29 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 18, } } 30 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 19, } } 31 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 19, } } 32 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 20, } } 33 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 20, } } 34 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 21, } } 35 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 22, } } 36 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 22, } } 37 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 23, } } 38 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 23, } } 39 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 24, } } 40 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 25, } } 41 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 25, } } 42 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 26, } } 43 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 26, } } 44 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 27, } } 45 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 28, } } 46 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 28, } } 47 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 29, } } 48 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 29, } } 49 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 30, } } 50 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 31, } } 51 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 31, } } 52 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 32, } } 53 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 32, } } 54 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 33, } } 55 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 34, } } 56 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 34, } } 57 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 35, } } 58 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 35, } } 59 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 36, } } 60 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 37, } } 61 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 37, } } 62 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 38, } } 63 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 38, } } 64 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 39, } } 65 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 40, } } 66 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 40, } } 67 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 41, } } 68 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 41, } } 69 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 42, } } 70 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 43, } } 71 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 43, } } 72 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 44, } } 73 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 44, } } 74 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 45, } } 75 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 46, } } 76 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 46, } } 77 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 47, } } 78 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 47, } } 79 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 48, } } 80 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 49, } } 81 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 49, } } 82 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 50, } } 83 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 50, } } 84 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 51, } } 85 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 52, } } 86 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 52, } } 87 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 53, } } 88 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 53, } } 89 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 54, } } 90 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 55, } } 91 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 55, } } 92 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 56, } } 93 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 56, } } 94 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 57, } } 95 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 58, } } 96 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 58, } } 97 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 59, } } 98 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 59, } } 99 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 60, } } 100 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 61, } } 101 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 62, } } 102 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 62, } } 103 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 62, } } 104 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 62, } } 105 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 63, } } 106 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 63, } } 107 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 64, } } 108 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 64, } } 109 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 64, } } 110 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 64, } } 111 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 64, } } 112 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 64, } } 113 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 65, } } 114 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 65, } } 115 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 66, } } 116 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 66, } } 117 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 66, } } 118 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 67, } } 119 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 67, } } 120 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 68, } } 121 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 68, } } 122 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 69, } } 123 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 69, } } 124 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 70, } } 125 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 71, } } 126 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 71, } } 127 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 72, } } 128 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 73, } } 129 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 73, } } 130 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 74, } } 131 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 74, } } 132 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 75, } } 133 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 75, } } 134 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 75, } } 135 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 75, } } 136 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 76, } } 137 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 76, } } 138 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 76, } } 139 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 76, } } 140 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 77, } } 141 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 77, } } 142 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 77, } } 143 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 77, } } 144 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 78, } } 145 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 78, } } 146 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 78, } } 147 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 78, } } 148 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 79, } } 149 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 79, } } 150 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 79, } } 151 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 79, } } 152 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 80, } } 153 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 80, } } 154 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 80, } } 155 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 80, } } 156 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 81, } } 157 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 81, } } 158 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 81, } } 159 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 81, } } 160 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 82, } } 161 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 82, } } 162 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 82, } } 163 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 82, } } 164 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 83, } } 165 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 83, } } 166 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 83, } } 167 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 83, } } 168 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 84, } } 169 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 84, } } 170 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 84, } } 171 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 84, } } 172 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 85, } } 173 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 85, } } 174 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 85, } } 175 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 85, } } 176 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 86, } } 177 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 86, } } 178 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 86, } } 179 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 86, } } 180 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 87, } } 181 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 88, } } 182 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 88, } } 183 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 88, } } 184 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 88, } } 185 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 89, } } 186 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 90, } } 187 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 90, } } 188 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 91, } } 189 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 92, } } 190 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 93, } } 191 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 93, } } 192 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 94, } } 193 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 94, } } 194 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 94, } } 195 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 94, } } 196 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 94, } } 197 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 94, } } 198 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 95, } } 199 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 96, } } 200 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 96, } } 201 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 97, } } 202 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 97, } } 203 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 204 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 205 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 206 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 207 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 208 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 209 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 210 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 211 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 212 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 213 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 214 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 215 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 98, } } 216 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 217 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 218 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 219 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 220 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 221 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 222 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 223 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 98, } } 224 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 225 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 226 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 227 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 98, } } 228 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 229 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 230 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 231 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 98, } } 232 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 98, } } 233 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 98, } } 234 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 235 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 236 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 237 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 238 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 8, nonterminal_produced: 98, } } 239 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 240 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 241 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 242 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 243 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 244 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 245 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 246 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 247 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 248 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 249 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 250 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 251 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 252 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 253 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 254 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 255 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 256 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 257 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 258 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 259 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 260 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 261 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 262 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 263 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 98, } } 264 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 265 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 266 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 267 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 268 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 269 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 270 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 8, nonterminal_produced: 98, } } 271 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 272 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 273 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 274 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 275 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 276 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 277 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 278 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 279 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 280 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 281 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 282 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 283 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 284 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 285 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 286 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 287 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 288 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 289 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 290 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 291 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 292 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 293 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 294 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 295 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 98, } } 296 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 297 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 298 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 299 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 300 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 8, nonterminal_produced: 98, } } 301 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 8, nonterminal_produced: 98, } } 302 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 9, nonterminal_produced: 98, } } 303 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 304 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 305 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 306 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 8, nonterminal_produced: 98, } } 307 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 308 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 309 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 310 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 8, nonterminal_produced: 98, } } 311 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 312 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 313 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 314 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 315 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 316 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 317 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 318 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 8, nonterminal_produced: 98, } } 319 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 320 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 321 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 322 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 323 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 324 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 325 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 326 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 98, } } 327 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 98, } } 328 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 329 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 98, } } 330 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 98, } } 331 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 99, } } 332 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 99, } } 333 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 99, } } 334 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 99, } } 335 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 100, } } 336 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 100, } } 337 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 101, } } 338 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 101, } } 339 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 102, } } 340 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 103, } } 341 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 103, } } 342 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 104, } } 343 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 105, } } 344 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 105, } } 345 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 106, } } 346 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 107, } } 347 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 107, } } 348 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 108, } } 349 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 108, } } 350 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 108, } } 351 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 109, } } 352 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 109, } } 353 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 110, } } 354 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 111, } } 355 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 111, } } 356 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 112, } } 357 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 112, } } 358 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 113, } } 359 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 114, } } 360 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 114, } } 361 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 115, } } 362 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 116, } } 363 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 117, } } 364 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 117, } } 365 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 117, } } 366 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 118, } } 367 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 118, } } 368 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 119, } } 369 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 120, } } 370 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 121, } } 371 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 122, } } 372 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 122, } } 373 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 123, } } 374 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 123, } } 375 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 123, } } 376 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 123, } } 377 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 124, } } 378 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 124, } } 379 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 124, } } 380 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 125, } } 381 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 126, } } 382 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 126, } } 383 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 127, } } 384 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 127, } } 385 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 127, } } 386 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 127, } } 387 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 128, } } 388 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 129, } } 389 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 129, } } 390 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 130, } } 391 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 130, } } 392 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 130, } } 393 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 130, } } 394 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 130, } } 395 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 130, } } 396 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 130, } } 397 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 130, } } 398 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 130, } } 399 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 130, } } 400 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 130, } } 401 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 130, } } 402 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 130, } } 403 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 131, } } 404 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 131, } } 405 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 131, } } 406 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 131, } } 407 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 132, } } 408 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 132, } } 409 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 132, } } 410 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 132, } } 411 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 133, } } 412 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 133, } } 413 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 134, } } 414 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 135, } } 415 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 136, } } 416 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 136, } } 417 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 136, } } 418 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 137, } } 419 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 138, } } 420 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 138, } } 421 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 139, } } 422 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 139, } } 423 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 140, } } 424 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 141, } } 425 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 141, } } 426 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 141, } } 427 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 141, } } 428 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 142, } } 429 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 142, } } 430 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 143, } } 431 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 143, } } 432 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 144, } } 433 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 144, } } 434 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 145, } } 435 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 146, } } 436 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 146, } } 437 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 147, } } 438 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 147, } } 439 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 147, } } 440 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 147, } } 441 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 147, } } 442 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 147, } } 443 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 147, } } 444 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 147, } } 445 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 148, } } 446 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 148, } } 447 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 149, } } 448 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 149, } } 449 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 149, } } 450 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 149, } } 451 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 149, } } 452 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 150, } } 453 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 10, nonterminal_produced: 150, } } 454 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 6, nonterminal_produced: 150, } } 455 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 8, nonterminal_produced: 150, } } 456 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 150, } } 457 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 8, nonterminal_produced: 150, } } 458 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 150, } } 459 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 150, } } 460 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 150, } } 461 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 151, } } 462 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 151, } } 463 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 152, } } 464 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 152, } } 465 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 152, } } 466 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 153, } } 467 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 153, } } 468 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 154, } } 469 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 155, } } 470 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 155, } } 471 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 156, } } 472 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 156, } } 473 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 157, } } 474 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 157, } } 475 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 157, } } 476 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 157, } } 477 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 3, nonterminal_produced: 157, } } 478 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 157, } } 479 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 157, } } 480 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 157, } } 481 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 157, } } 482 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 157, } } 483 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 11, nonterminal_produced: 157, } } 484 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 7, nonterminal_produced: 157, } } 485 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 9, nonterminal_produced: 157, } } 486 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 5, nonterminal_produced: 157, } } 487 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 158, } } 488 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 158, } } 489 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 159, } } 490 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 159, } } 491 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 160, } } 492 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 160, } } 493 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 161, } } 494 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 162, } } 495 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 162, } } 496 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 163, } } 497 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 2, nonterminal_produced: 163, } } 498 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 4, nonterminal_produced: 164, } } 499 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 1, nonterminal_produced: 164, } } 500 => { ___state_machine::SimulatedReduce::Reduce { states_to_pop: 0, nonterminal_produced: 164, } } 501 => ___state_machine::SimulatedReduce::Accept, _ => panic!("invalid reduction index {}", ___reduce_index) } } pub struct TopParser { _priv: (), } impl TopParser { pub fn new() -> TopParser { TopParser { _priv: (), } } #[allow(dead_code)] pub fn parse< 'input, ___TOKEN: ___ToTriple<'input, >, ___TOKENS: IntoIterator, >( &self, text: &'input str, ___tokens0: ___TOKENS, ) -> Result, tok::Error>> { let ___tokens = ___tokens0.into_iter(); let mut ___tokens = ___tokens.map(|t| ___ToTriple::to_triple(t)); let ___r = ___state_machine::Parser::drive( ___StateMachine { text, ___phantom: ::std::marker::PhantomData::<(&())>, }, ___tokens, ); ___r } } pub(crate) fn ___reduce< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> Option, tok::Error>>> { let (___pop_states, ___nonterminal) = match ___action { 0 => { ___reduce0(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 1 => { ___reduce1(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 2 => { ___reduce2(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 3 => { ___reduce3(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 4 => { ___reduce4(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 5 => { ___reduce5(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 6 => { ___reduce6(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 7 => { ___reduce7(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 8 => { ___reduce8(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 9 => { ___reduce9(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 10 => { ___reduce10(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 11 => { ___reduce11(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 12 => { ___reduce12(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 13 => { ___reduce13(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 14 => { ___reduce14(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 15 => { ___reduce15(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 16 => { ___reduce16(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 17 => { ___reduce17(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 18 => { ___reduce18(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 19 => { ___reduce19(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 20 => { ___reduce20(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 21 => { ___reduce21(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 22 => { ___reduce22(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 23 => { ___reduce23(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 24 => { ___reduce24(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 25 => { ___reduce25(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 26 => { ___reduce26(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 27 => { ___reduce27(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 28 => { ___reduce28(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 29 => { ___reduce29(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 30 => { ___reduce30(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 31 => { ___reduce31(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 32 => { ___reduce32(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 33 => { ___reduce33(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 34 => { ___reduce34(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 35 => { ___reduce35(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 36 => { ___reduce36(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 37 => { ___reduce37(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 38 => { ___reduce38(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 39 => { ___reduce39(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 40 => { ___reduce40(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 41 => { ___reduce41(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 42 => { ___reduce42(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 43 => { ___reduce43(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 44 => { ___reduce44(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 45 => { ___reduce45(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 46 => { ___reduce46(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 47 => { ___reduce47(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 48 => { ___reduce48(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 49 => { ___reduce49(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 50 => { ___reduce50(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 51 => { ___reduce51(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 52 => { ___reduce52(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 53 => { ___reduce53(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 54 => { ___reduce54(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 55 => { ___reduce55(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 56 => { ___reduce56(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 57 => { ___reduce57(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 58 => { ___reduce58(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 59 => { ___reduce59(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 60 => { ___reduce60(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 61 => { ___reduce61(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 62 => { ___reduce62(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 63 => { ___reduce63(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 64 => { ___reduce64(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 65 => { ___reduce65(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 66 => { ___reduce66(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 67 => { ___reduce67(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 68 => { ___reduce68(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 69 => { ___reduce69(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 70 => { ___reduce70(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 71 => { ___reduce71(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 72 => { ___reduce72(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 73 => { ___reduce73(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 74 => { ___reduce74(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 75 => { ___reduce75(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 76 => { ___reduce76(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 77 => { ___reduce77(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 78 => { ___reduce78(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 79 => { ___reduce79(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 80 => { ___reduce80(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 81 => { ___reduce81(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 82 => { ___reduce82(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 83 => { ___reduce83(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 84 => { ___reduce84(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 85 => { ___reduce85(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 86 => { ___reduce86(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 87 => { ___reduce87(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 88 => { ___reduce88(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 89 => { ___reduce89(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 90 => { ___reduce90(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 91 => { ___reduce91(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 92 => { ___reduce92(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 93 => { ___reduce93(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 94 => { ___reduce94(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 95 => { ___reduce95(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 96 => { ___reduce96(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 97 => { ___reduce97(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 98 => { ___reduce98(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 99 => { ___reduce99(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 100 => { ___reduce100(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 101 => { ___reduce101(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 102 => { ___reduce102(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 103 => { ___reduce103(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 104 => { ___reduce104(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 105 => { ___reduce105(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 106 => { ___reduce106(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 107 => { ___reduce107(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 108 => { ___reduce108(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 109 => { ___reduce109(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 110 => { ___reduce110(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 111 => { ___reduce111(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 112 => { ___reduce112(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 113 => { ___reduce113(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 114 => { ___reduce114(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 115 => { ___reduce115(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 116 => { ___reduce116(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 117 => { ___reduce117(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 118 => { ___reduce118(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 119 => { ___reduce119(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 120 => { ___reduce120(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 121 => { ___reduce121(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 122 => { ___reduce122(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 123 => { ___reduce123(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 124 => { ___reduce124(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 125 => { ___reduce125(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 126 => { ___reduce126(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 127 => { ___reduce127(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 128 => { ___reduce128(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 129 => { ___reduce129(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 130 => { ___reduce130(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 131 => { ___reduce131(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 132 => { ___reduce132(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 133 => { ___reduce133(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 134 => { ___reduce134(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 135 => { ___reduce135(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 136 => { ___reduce136(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 137 => { ___reduce137(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 138 => { ___reduce138(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 139 => { ___reduce139(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 140 => { ___reduce140(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 141 => { ___reduce141(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 142 => { ___reduce142(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 143 => { ___reduce143(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 144 => { ___reduce144(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 145 => { ___reduce145(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 146 => { ___reduce146(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 147 => { ___reduce147(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 148 => { ___reduce148(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 149 => { ___reduce149(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 150 => { ___reduce150(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 151 => { ___reduce151(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 152 => { ___reduce152(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 153 => { ___reduce153(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 154 => { ___reduce154(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 155 => { ___reduce155(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 156 => { ___reduce156(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 157 => { ___reduce157(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 158 => { ___reduce158(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 159 => { ___reduce159(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 160 => { ___reduce160(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 161 => { ___reduce161(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 162 => { ___reduce162(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 163 => { ___reduce163(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 164 => { ___reduce164(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 165 => { ___reduce165(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 166 => { ___reduce166(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 167 => { ___reduce167(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 168 => { ___reduce168(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 169 => { ___reduce169(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 170 => { ___reduce170(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 171 => { ___reduce171(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 172 => { ___reduce172(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 173 => { ___reduce173(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 174 => { ___reduce174(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 175 => { ___reduce175(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 176 => { ___reduce176(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 177 => { ___reduce177(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 178 => { ___reduce178(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 179 => { ___reduce179(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 180 => { ___reduce180(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 181 => { ___reduce181(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 182 => { ___reduce182(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 183 => { ___reduce183(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 184 => { ___reduce184(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 185 => { // Conversion = Terminal, "=>" => ActionFn(424); let ___sym1 = ___pop_Variant1(___symbols); let ___sym0 = ___pop_Variant75(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = match super::___action424::<>(text, ___sym0, ___sym1) { Ok(v) => v, Err(e) => return Some(Err(e)), }; ___symbols.push((___start, ___Symbol::Variant12(___nt), ___end)); (2, 89) } 186 => { ___reduce186(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 187 => { ___reduce187(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 188 => { ___reduce188(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 189 => { ___reduce189(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 190 => { ___reduce190(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 191 => { ___reduce191(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 192 => { ___reduce192(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 193 => { ___reduce193(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 194 => { ___reduce194(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 195 => { ___reduce195(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 196 => { ___reduce196(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 197 => { ___reduce197(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 198 => { ___reduce198(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 199 => { ___reduce199(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 200 => { ___reduce200(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 201 => { ___reduce201(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 202 => { ___reduce202(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 203 => { ___reduce203(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 204 => { ___reduce204(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 205 => { ___reduce205(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 206 => { ___reduce206(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 207 => { ___reduce207(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 208 => { ___reduce208(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 209 => { ___reduce209(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 210 => { ___reduce210(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 211 => { ___reduce211(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 212 => { ___reduce212(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 213 => { ___reduce213(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 214 => { ___reduce214(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 215 => { ___reduce215(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 216 => { ___reduce216(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 217 => { ___reduce217(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 218 => { ___reduce218(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 219 => { ___reduce219(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 220 => { ___reduce220(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 221 => { ___reduce221(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 222 => { ___reduce222(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 223 => { ___reduce223(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 224 => { ___reduce224(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 225 => { ___reduce225(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 226 => { ___reduce226(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 227 => { ___reduce227(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 228 => { ___reduce228(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 229 => { ___reduce229(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 230 => { ___reduce230(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 231 => { ___reduce231(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 232 => { ___reduce232(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 233 => { ___reduce233(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 234 => { ___reduce234(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 235 => { ___reduce235(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 236 => { ___reduce236(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 237 => { ___reduce237(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 238 => { ___reduce238(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 239 => { ___reduce239(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 240 => { ___reduce240(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 241 => { ___reduce241(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 242 => { ___reduce242(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 243 => { ___reduce243(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 244 => { ___reduce244(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 245 => { ___reduce245(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 246 => { ___reduce246(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 247 => { ___reduce247(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 248 => { ___reduce248(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 249 => { ___reduce249(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 250 => { ___reduce250(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 251 => { ___reduce251(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 252 => { ___reduce252(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 253 => { ___reduce253(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 254 => { ___reduce254(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 255 => { ___reduce255(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 256 => { ___reduce256(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 257 => { ___reduce257(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 258 => { ___reduce258(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 259 => { ___reduce259(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 260 => { ___reduce260(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 261 => { ___reduce261(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 262 => { ___reduce262(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 263 => { ___reduce263(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 264 => { ___reduce264(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 265 => { ___reduce265(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 266 => { ___reduce266(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 267 => { ___reduce267(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 268 => { ___reduce268(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 269 => { ___reduce269(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 270 => { ___reduce270(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 271 => { ___reduce271(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 272 => { ___reduce272(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 273 => { ___reduce273(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 274 => { ___reduce274(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 275 => { ___reduce275(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 276 => { ___reduce276(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 277 => { ___reduce277(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 278 => { ___reduce278(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 279 => { ___reduce279(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 280 => { ___reduce280(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 281 => { ___reduce281(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 282 => { ___reduce282(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 283 => { ___reduce283(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 284 => { ___reduce284(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 285 => { ___reduce285(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 286 => { ___reduce286(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 287 => { ___reduce287(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 288 => { ___reduce288(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 289 => { ___reduce289(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 290 => { ___reduce290(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 291 => { ___reduce291(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 292 => { ___reduce292(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 293 => { ___reduce293(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 294 => { ___reduce294(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 295 => { ___reduce295(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 296 => { ___reduce296(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 297 => { ___reduce297(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 298 => { ___reduce298(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 299 => { ___reduce299(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 300 => { ___reduce300(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 301 => { ___reduce301(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 302 => { ___reduce302(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 303 => { ___reduce303(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 304 => { ___reduce304(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 305 => { ___reduce305(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 306 => { ___reduce306(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 307 => { ___reduce307(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 308 => { ___reduce308(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 309 => { ___reduce309(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 310 => { ___reduce310(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 311 => { ___reduce311(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 312 => { ___reduce312(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 313 => { ___reduce313(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 314 => { ___reduce314(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 315 => { ___reduce315(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 316 => { ___reduce316(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 317 => { ___reduce317(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 318 => { ___reduce318(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 319 => { ___reduce319(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 320 => { ___reduce320(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 321 => { ___reduce321(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 322 => { ___reduce322(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 323 => { ___reduce323(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 324 => { ___reduce324(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 325 => { ___reduce325(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 326 => { ___reduce326(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 327 => { ___reduce327(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 328 => { ___reduce328(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 329 => { ___reduce329(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 330 => { ___reduce330(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 331 => { ___reduce331(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 332 => { ___reduce332(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 333 => { ___reduce333(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 334 => { ___reduce334(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 335 => { ___reduce335(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 336 => { ___reduce336(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 337 => { ___reduce337(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 338 => { ___reduce338(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 339 => { ___reduce339(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 340 => { ___reduce340(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 341 => { ___reduce341(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 342 => { ___reduce342(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 343 => { ___reduce343(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 344 => { ___reduce344(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 345 => { ___reduce345(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 346 => { ___reduce346(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 347 => { ___reduce347(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 348 => { ___reduce348(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 349 => { ___reduce349(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 350 => { ___reduce350(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 351 => { ___reduce351(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 352 => { ___reduce352(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 353 => { ___reduce353(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 354 => { ___reduce354(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 355 => { ___reduce355(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 356 => { ___reduce356(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 357 => { ___reduce357(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 358 => { ___reduce358(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 359 => { ___reduce359(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 360 => { ___reduce360(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 361 => { ___reduce361(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 362 => { ___reduce362(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 363 => { ___reduce363(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 364 => { ___reduce364(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 365 => { // MatchItem = MatchSymbol, "=>" => ActionFn(432); let ___sym1 = ___pop_Variant1(___symbols); let ___sym0 = ___pop_Variant76(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = match super::___action432::<>(text, ___sym0, ___sym1) { Ok(v) => v, Err(e) => return Some(Err(e)), }; ___symbols.push((___start, ___Symbol::Variant24(___nt), ___end)); (2, 117) } 366 => { ___reduce366(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 367 => { ___reduce367(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 368 => { ___reduce368(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 369 => { ___reduce369(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 370 => { ___reduce370(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 371 => { ___reduce371(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 372 => { ___reduce372(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 373 => { ___reduce373(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 374 => { ___reduce374(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 375 => { ___reduce375(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 376 => { ___reduce376(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 377 => { ___reduce377(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 378 => { ___reduce378(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 379 => { ___reduce379(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 380 => { ___reduce380(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 381 => { ___reduce381(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 382 => { ___reduce382(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 383 => { ___reduce383(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 384 => { ___reduce384(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 385 => { ___reduce385(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 386 => { ___reduce386(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 387 => { ___reduce387(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 388 => { ___reduce388(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 389 => { ___reduce389(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 390 => { ___reduce390(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 391 => { ___reduce391(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 392 => { ___reduce392(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 393 => { ___reduce393(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 394 => { ___reduce394(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 395 => { ___reduce395(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 396 => { ___reduce396(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 397 => { ___reduce397(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 398 => { ___reduce398(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 399 => { ___reduce399(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 400 => { ___reduce400(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 401 => { ___reduce401(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 402 => { ___reduce402(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 403 => { ___reduce403(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 404 => { ___reduce404(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 405 => { ___reduce405(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 406 => { ___reduce406(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 407 => { ___reduce407(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 408 => { ___reduce408(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 409 => { ___reduce409(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 410 => { ___reduce410(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 411 => { ___reduce411(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 412 => { ___reduce412(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 413 => { ___reduce413(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 414 => { ___reduce414(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 415 => { ___reduce415(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 416 => { ___reduce416(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 417 => { ___reduce417(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 418 => { ___reduce418(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 419 => { ___reduce419(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 420 => { ___reduce420(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 421 => { ___reduce421(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 422 => { ___reduce422(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 423 => { // StringLiteral = "StringLiteral" => ActionFn(412); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = match super::___action412::<>(text, ___sym0) { Ok(v) => v, Err(e) => return Some(Err(e)), }; ___symbols.push((___start, ___Symbol::Variant20(___nt), ___end)); (1, 140) } 424 => { ___reduce424(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 425 => { ___reduce425(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 426 => { ___reduce426(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 427 => { ___reduce427(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 428 => { ___reduce428(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 429 => { ___reduce429(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 430 => { ___reduce430(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 431 => { ___reduce431(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 432 => { ___reduce432(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 433 => { ___reduce433(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 434 => { ___reduce434(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 435 => { ___reduce435(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 436 => { ___reduce436(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 437 => { ___reduce437(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 438 => { ___reduce438(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 439 => { ___reduce439(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 440 => { ___reduce440(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 441 => { ___reduce441(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 442 => { ___reduce442(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 443 => { ___reduce443(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 444 => { ___reduce444(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 445 => { ___reduce445(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 446 => { ___reduce446(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 447 => { ___reduce447(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 448 => { ___reduce448(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 449 => { ___reduce449(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 450 => { ___reduce450(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 451 => { ___reduce451(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 452 => { ___reduce452(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 453 => { ___reduce453(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 454 => { ___reduce454(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 455 => { ___reduce455(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 456 => { ___reduce456(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 457 => { ___reduce457(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 458 => { ___reduce458(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 459 => { ___reduce459(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 460 => { ___reduce460(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 461 => { ___reduce461(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 462 => { ___reduce462(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 463 => { ___reduce463(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 464 => { ___reduce464(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 465 => { ___reduce465(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 466 => { ___reduce466(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 467 => { ___reduce467(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 468 => { ___reduce468(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 469 => { ___reduce469(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 470 => { ___reduce470(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 471 => { ___reduce471(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 472 => { ___reduce472(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 473 => { ___reduce473(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 474 => { ___reduce474(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 475 => { ___reduce475(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 476 => { ___reduce476(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 477 => { ___reduce477(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 478 => { ___reduce478(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 479 => { ___reduce479(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 480 => { ___reduce480(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 481 => { ___reduce481(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 482 => { ___reduce482(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 483 => { ___reduce483(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 484 => { ___reduce484(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 485 => { ___reduce485(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 486 => { ___reduce486(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 487 => { ___reduce487(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 488 => { ___reduce488(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 489 => { ___reduce489(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 490 => { ___reduce490(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 491 => { ___reduce491(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 492 => { ___reduce492(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 493 => { ___reduce493(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 494 => { ___reduce494(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 495 => { ___reduce495(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 496 => { ___reduce496(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 497 => { ___reduce497(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 498 => { ___reduce498(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 499 => { ___reduce499(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 500 => { ___reduce500(text, ___action, ___lookahead_start, ___states, ___symbols, ::std::marker::PhantomData::<(&())>) } 501 => { // ___Top = Top => ActionFn(0); let ___sym0 = ___pop_Variant90(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action0::<>(text, ___sym0); return Some(Ok(___nt)); } _ => panic!("invalid action code {}", ___action) }; let ___states_len = ___states.len(); ___states.truncate(___states_len - ___pop_states); let ___state = *___states.last().unwrap() as usize; let ___next_state = ___GOTO[___state * 166 + ___nonterminal] - 1; ___states.push(___next_state); None } fn ___pop_Variant9< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, (), usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant9(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant46< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, (Atom, String), usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant46(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant78< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, (NonterminalString, Vec), usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant78(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant40< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ActionKind, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant40(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant10< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Alternative, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant10(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant44< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Annotation, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant44(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant48< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, AssociatedType, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant48(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant20< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Atom, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant20(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant7< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Condition, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant7(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant59< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ConditionOp, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant59(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant12< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Conversion, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant12(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant61< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, EnumToken, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant61(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant62< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ExprSymbol, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant62(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant14< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, FieldPattern, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant14(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant65< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Grammar, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant65(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant63< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, GrammarItem, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant63(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant22< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Lifetime, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant22(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant73< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, MatchContents, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant73(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant24< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, MatchItem, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant24(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant77< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, MatchToken, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant77(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant26< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, NonterminalString, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant26(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant16< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Parameter, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant16(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant80< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Path, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant80(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant28< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Pattern, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant28(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant82< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, PatternKind, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant82(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant85< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, RepeatOp, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant85(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant86< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, String, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant86(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant30< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Symbol, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant30(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant89< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, SymbolKind, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant89(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant76< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, TerminalLiteral, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant76(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant75< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, TerminalString, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant75(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant0< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Tok<'input>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant0(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant90< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Top, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant90(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant32< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, TypeBound, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant32(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant34< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, TypeBoundParameter, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant34(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant36< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, TypeParameter, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant36(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant3< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, TypeRef, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant3(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant43< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant43(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant50< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant50(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant83< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant83(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant53< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant53(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant54< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant54(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant51< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant51(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant55< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant55(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant56< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant56(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant84< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant84(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant5< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant5(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant57< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant57(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant58< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant58(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant52< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Vec>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant52(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant94< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, Visibility, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant94(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant18< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, WhereClause, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant18(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant39< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, usize, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant39(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant47< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option<(Atom, String)>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant47(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant41< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant41(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant42< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant42(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant8< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant8(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant60< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant60(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant64< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant64(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant72< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant72(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant74< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant74(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant79< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant79(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant67< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant67(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant81< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant81(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant88< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant88(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant2< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant2(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant91< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant91(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant92< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant92(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant93< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant93(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant4< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant4(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant68< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant68(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant6< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant6(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant69< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant69(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant71< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant71(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant70< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::option::Option>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant70(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant11< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant11(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant45< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant45(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant49< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant49(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant21< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant21(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant13< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant13(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant15< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant15(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant66< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant66(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant23< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant23(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant25< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant25(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant27< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant27(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant17< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant17(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant29< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant29(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant87< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant87(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant31< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant31(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant33< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant33(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant35< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant35(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant37< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant37(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant38< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant38(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant19< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, ::std::vec::Vec>, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant19(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } fn ___pop_Variant1< 'input, >( ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)> ) -> (usize, &'input str, usize) { match ___symbols.pop().unwrap() { (___l, ___Symbol::Variant1(___v), ___r) => (___l, ___v, ___r), _ => panic!("symbol type mismatch") } } pub(crate) fn ___reduce0< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // "::"? = "::" => ActionFn(132); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action132::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant2(___nt), ___end)); (1, 0) } pub(crate) fn ___reduce1< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // "::"? = => ActionFn(133); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action133::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant2(___nt), ___end)); (0, 0) } pub(crate) fn ___reduce2< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ";"? = ";" => ActionFn(149); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action149::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant2(___nt), ___end)); (1, 1) } pub(crate) fn ___reduce3< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ";"? = => ActionFn(150); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action150::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant2(___nt), ___end)); (0, 1) } pub(crate) fn ___reduce4< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // "mut"? = "mut" => ActionFn(138); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action138::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant2(___nt), ___end)); (1, 2) } pub(crate) fn ___reduce5< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // "mut"? = => ActionFn(139); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action139::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant2(___nt), ___end)); (0, 2) } pub(crate) fn ___reduce6< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ("->" ) = "->", TypeRef => ActionFn(165); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action165::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (2, 3) } pub(crate) fn ___reduce7< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ("->" )? = "->", TypeRef => ActionFn(306); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action306::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant4(___nt), ___end)); (2, 4) } pub(crate) fn ___reduce8< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ("->" )? = => ActionFn(164); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action164::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant4(___nt), ___end)); (0, 4) } pub(crate) fn ___reduce9< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // (":" ) = ":", TypeRef => ActionFn(157); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action157::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (2, 5) } pub(crate) fn ___reduce10< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // (":" )? = ":", TypeRef => ActionFn(311); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action311::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant4(___nt), ___end)); (2, 6) } pub(crate) fn ___reduce11< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // (":" )? = => ActionFn(156); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action156::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant4(___nt), ___end)); (0, 6) } pub(crate) fn ___reduce12< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ("<" > ">") = "<", Comma, ">" => ActionFn(161); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant5(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action161::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant5(___nt), ___end)); (3, 7) } pub(crate) fn ___reduce13< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ("<" > ">")? = "<", Comma, ">" => ActionFn(314); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant5(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action314::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant6(___nt), ___end)); (3, 8) } pub(crate) fn ___reduce14< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ("<" > ">")? = => ActionFn(160); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action160::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant6(___nt), ___end)); (0, 8) } pub(crate) fn ___reduce15< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ("if" ) = "if", Cond => ActionFn(146); let ___sym1 = ___pop_Variant7(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action146::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant7(___nt), ___end)); (2, 9) } pub(crate) fn ___reduce16< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ("if" )? = "if", Cond => ActionFn(317); let ___sym1 = ___pop_Variant7(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action317::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant8(___nt), ___end)); (2, 10) } pub(crate) fn ___reduce17< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ("if" )? = => ActionFn(145); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action145::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant8(___nt), ___end)); (0, 10) } pub(crate) fn ___reduce18< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // () = => ActionFn(168); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action168::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant9(___nt), ___end)); (0, 11) } pub(crate) fn ___reduce19< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = Alternative, "," => ActionFn(238); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant10(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action238::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant10(___nt), ___end)); (2, 12) } pub(crate) fn ___reduce20< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(236); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action236::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant11(___nt), ___end)); (0, 13) } pub(crate) fn ___reduce21< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(237); let ___sym0 = ___pop_Variant11(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action237::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant11(___nt), ___end)); (1, 13) } pub(crate) fn ___reduce22< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = Alternative, "," => ActionFn(324); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant10(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action324::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant11(___nt), ___end)); (2, 14) } pub(crate) fn ___reduce23< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, Alternative, "," => ActionFn(325); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant10(___symbols); let ___sym0 = ___pop_Variant11(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action325::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant11(___nt), ___end)); (3, 14) } pub(crate) fn ___reduce24< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = Conversion, "," => ActionFn(262); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant12(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action262::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant12(___nt), ___end)); (2, 15) } pub(crate) fn ___reduce25< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(260); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action260::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant13(___nt), ___end)); (0, 16) } pub(crate) fn ___reduce26< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(261); let ___sym0 = ___pop_Variant13(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action261::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant13(___nt), ___end)); (1, 16) } pub(crate) fn ___reduce27< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = Conversion, "," => ActionFn(328); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant12(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action328::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant13(___nt), ___end)); (2, 17) } pub(crate) fn ___reduce28< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, Conversion, "," => ActionFn(329); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant12(___symbols); let ___sym0 = ___pop_Variant13(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action329::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant13(___nt), ___end)); (3, 17) } pub(crate) fn ___reduce29< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = FieldPattern, "," => ActionFn(123); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant14(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action123::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant14(___nt), ___end)); (2, 18) } pub(crate) fn ___reduce30< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(121); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action121::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant15(___nt), ___end)); (0, 19) } pub(crate) fn ___reduce31< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(122); let ___sym0 = ___pop_Variant15(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action122::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant15(___nt), ___end)); (1, 19) } pub(crate) fn ___reduce32< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = FieldPattern, "," => ActionFn(332); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant14(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action332::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant15(___nt), ___end)); (2, 20) } pub(crate) fn ___reduce33< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, FieldPattern, "," => ActionFn(333); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant14(___symbols); let ___sym0 = ___pop_Variant15(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action333::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant15(___nt), ___end)); (3, 20) } pub(crate) fn ___reduce34< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = GrammarParameter, "," => ActionFn(228); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant16(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action228::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant16(___nt), ___end)); (2, 21) } pub(crate) fn ___reduce35< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(226); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action226::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant17(___nt), ___end)); (0, 22) } pub(crate) fn ___reduce36< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(227); let ___sym0 = ___pop_Variant17(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action227::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant17(___nt), ___end)); (1, 22) } pub(crate) fn ___reduce37< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = GrammarParameter, "," => ActionFn(338); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant16(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action338::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant17(___nt), ___end)); (2, 23) } pub(crate) fn ___reduce38< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, GrammarParameter, "," => ActionFn(339); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant16(___symbols); let ___sym0 = ___pop_Variant17(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action339::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant17(___nt), ___end)); (3, 23) } pub(crate) fn ___reduce39< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = GrammarWhereClause, "," => ActionFn(205); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant18(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action205::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant18(___nt), ___end)); (2, 24) } pub(crate) fn ___reduce40< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(203); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action203::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant19(___nt), ___end)); (0, 25) } pub(crate) fn ___reduce41< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(204); let ___sym0 = ___pop_Variant19(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action204::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant19(___nt), ___end)); (1, 25) } pub(crate) fn ___reduce42< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = GrammarWhereClause, "," => ActionFn(342); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant18(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action342::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant19(___nt), ___end)); (2, 26) } pub(crate) fn ___reduce43< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, GrammarWhereClause, "," => ActionFn(343); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant18(___symbols); let ___sym0 = ___pop_Variant19(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action343::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant19(___nt), ___end)); (3, 26) } pub(crate) fn ___reduce44< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "::") = Id, "::" => ActionFn(131); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action131::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant20(___nt), ___end)); (2, 27) } pub(crate) fn ___reduce45< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "::")* = => ActionFn(129); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action129::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant21(___nt), ___end)); (0, 28) } pub(crate) fn ___reduce46< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "::")* = ( "::")+ => ActionFn(130); let ___sym0 = ___pop_Variant21(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action130::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant21(___nt), ___end)); (1, 28) } pub(crate) fn ___reduce47< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "::")+ = Id, "::" => ActionFn(346); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action346::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant21(___nt), ___end)); (2, 29) } pub(crate) fn ___reduce48< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "::")+ = ( "::")+, Id, "::" => ActionFn(347); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant20(___symbols); let ___sym0 = ___pop_Variant21(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action347::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant21(___nt), ___end)); (3, 29) } pub(crate) fn ___reduce49< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+") = Lifetime, "+" => ActionFn(208); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant22(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action208::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant22(___nt), ___end)); (2, 30) } pub(crate) fn ___reduce50< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+")* = => ActionFn(206); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action206::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant23(___nt), ___end)); (0, 31) } pub(crate) fn ___reduce51< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+")* = ( "+")+ => ActionFn(207); let ___sym0 = ___pop_Variant23(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action207::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant23(___nt), ___end)); (1, 31) } pub(crate) fn ___reduce52< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+")+ = Lifetime, "+" => ActionFn(352); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant22(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action352::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant23(___nt), ___end)); (2, 32) } pub(crate) fn ___reduce53< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+")+ = ( "+")+, Lifetime, "+" => ActionFn(353); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant22(___symbols); let ___sym0 = ___pop_Variant23(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action353::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant23(___nt), ___end)); (3, 32) } pub(crate) fn ___reduce54< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = MatchItem, "," => ActionFn(257); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant24(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action257::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant24(___nt), ___end)); (2, 33) } pub(crate) fn ___reduce55< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(255); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action255::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant25(___nt), ___end)); (0, 34) } pub(crate) fn ___reduce56< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(256); let ___sym0 = ___pop_Variant25(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action256::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant25(___nt), ___end)); (1, 34) } pub(crate) fn ___reduce57< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = MatchItem, "," => ActionFn(356); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant24(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action356::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant25(___nt), ___end)); (2, 35) } pub(crate) fn ___reduce58< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, MatchItem, "," => ActionFn(357); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant24(___symbols); let ___sym0 = ___pop_Variant25(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action357::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant25(___nt), ___end)); (3, 35) } pub(crate) fn ___reduce59< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = NotMacroId, "," => ActionFn(233); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant26(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action233::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant26(___nt), ___end)); (2, 36) } pub(crate) fn ___reduce60< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(231); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action231::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant27(___nt), ___end)); (0, 37) } pub(crate) fn ___reduce61< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(232); let ___sym0 = ___pop_Variant27(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action232::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant27(___nt), ___end)); (1, 37) } pub(crate) fn ___reduce62< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = NotMacroId, "," => ActionFn(360); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant26(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action360::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant27(___nt), ___end)); (2, 38) } pub(crate) fn ___reduce63< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, NotMacroId, "," => ActionFn(361); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant26(___symbols); let ___sym0 = ___pop_Variant27(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action361::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant27(___nt), ___end)); (3, 38) } pub(crate) fn ___reduce64< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = Pattern, "," => ActionFn(267); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant28(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action267::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant28(___nt), ___end)); (2, 39) } pub(crate) fn ___reduce65< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(265); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action265::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant29(___nt), ___end)); (0, 40) } pub(crate) fn ___reduce66< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(266); let ___sym0 = ___pop_Variant29(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action266::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant29(___nt), ___end)); (1, 40) } pub(crate) fn ___reduce67< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = Pattern, "," => ActionFn(364); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant28(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action364::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant29(___nt), ___end)); (2, 41) } pub(crate) fn ___reduce68< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, Pattern, "," => ActionFn(365); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant28(___symbols); let ___sym0 = ___pop_Variant29(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action365::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant29(___nt), ___end)); (3, 41) } pub(crate) fn ___reduce69< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = Symbol, "," => ActionFn(243); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant30(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action243::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant30(___nt), ___end)); (2, 42) } pub(crate) fn ___reduce70< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(241); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action241::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant31(___nt), ___end)); (0, 43) } pub(crate) fn ___reduce71< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(242); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action242::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant31(___nt), ___end)); (1, 43) } pub(crate) fn ___reduce72< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = Symbol, "," => ActionFn(368); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant30(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action368::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant31(___nt), ___end)); (2, 44) } pub(crate) fn ___reduce73< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, Symbol, "," => ActionFn(369); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant30(___symbols); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action369::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant31(___nt), ___end)); (3, 44) } pub(crate) fn ___reduce74< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+") = TypeBound, "+" => ActionFn(213); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant32(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action213::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (2, 45) } pub(crate) fn ___reduce75< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+")* = => ActionFn(211); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action211::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant33(___nt), ___end)); (0, 46) } pub(crate) fn ___reduce76< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+")* = ( "+")+ => ActionFn(212); let ___sym0 = ___pop_Variant33(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action212::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant33(___nt), ___end)); (1, 46) } pub(crate) fn ___reduce77< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+")+ = TypeBound, "+" => ActionFn(372); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant32(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action372::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant33(___nt), ___end)); (2, 47) } pub(crate) fn ___reduce78< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( "+")+ = ( "+")+, TypeBound, "+" => ActionFn(373); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant32(___symbols); let ___sym0 = ___pop_Variant33(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action373::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant33(___nt), ___end)); (3, 47) } pub(crate) fn ___reduce79< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = TypeBoundParameter, "," => ActionFn(223); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant34(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action223::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant34(___nt), ___end)); (2, 48) } pub(crate) fn ___reduce80< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(221); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action221::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant35(___nt), ___end)); (0, 49) } pub(crate) fn ___reduce81< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(222); let ___sym0 = ___pop_Variant35(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action222::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant35(___nt), ___end)); (1, 49) } pub(crate) fn ___reduce82< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = TypeBoundParameter, "," => ActionFn(376); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant34(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action376::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant35(___nt), ___end)); (2, 50) } pub(crate) fn ___reduce83< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, TypeBoundParameter, "," => ActionFn(377); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant34(___symbols); let ___sym0 = ___pop_Variant35(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action377::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant35(___nt), ___end)); (3, 50) } pub(crate) fn ___reduce84< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = TypeParameter, "," => ActionFn(200); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant36(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action200::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant36(___nt), ___end)); (2, 51) } pub(crate) fn ___reduce85< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(198); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action198::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant37(___nt), ___end)); (0, 52) } pub(crate) fn ___reduce86< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(199); let ___sym0 = ___pop_Variant37(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action199::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant37(___nt), ___end)); (1, 52) } pub(crate) fn ___reduce87< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = TypeParameter, "," => ActionFn(380); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant36(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action380::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant37(___nt), ___end)); (2, 53) } pub(crate) fn ___reduce88< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, TypeParameter, "," => ActionFn(381); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant36(___symbols); let ___sym0 = ___pop_Variant37(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action381::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant37(___nt), ___end)); (3, 53) } pub(crate) fn ___reduce89< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = TypeRef, "," => ActionFn(218); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action218::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (2, 54) } pub(crate) fn ___reduce90< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(216); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action216::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant38(___nt), ___end)); (0, 55) } pub(crate) fn ___reduce91< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(217); let ___sym0 = ___pop_Variant38(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action217::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant38(___nt), ___end)); (1, 55) } pub(crate) fn ___reduce92< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = TypeRef, "," => ActionFn(384); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action384::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant38(___nt), ___end)); (2, 56) } pub(crate) fn ___reduce93< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, TypeRef, "," => ActionFn(385); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant38(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action385::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant38(___nt), ___end)); (3, 56) } pub(crate) fn ___reduce94< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",") = TypeRefOrLifetime, "," => ActionFn(248); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action248::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (2, 57) } pub(crate) fn ___reduce95< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = => ActionFn(246); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action246::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant38(___nt), ___end)); (0, 58) } pub(crate) fn ___reduce96< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")* = ( ",")+ => ActionFn(247); let ___sym0 = ___pop_Variant38(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action247::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant38(___nt), ___end)); (1, 58) } pub(crate) fn ___reduce97< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = TypeRefOrLifetime, "," => ActionFn(388); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action388::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant38(___nt), ___end)); (2, 59) } pub(crate) fn ___reduce98< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ( ",")+ = ( ",")+, TypeRefOrLifetime, "," => ActionFn(389); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant38(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action389::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant38(___nt), ___end)); (3, 59) } pub(crate) fn ___reduce99< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // @L = => ActionFn(181); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action181::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant39(___nt), ___end)); (0, 60) } pub(crate) fn ___reduce100< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // @R = => ActionFn(180); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action180::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant39(___nt), ___end)); (0, 61) } pub(crate) fn ___reduce101< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Action = "=>@L" => ActionFn(42); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action42::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant40(___nt), ___end)); (1, 62) } pub(crate) fn ___reduce102< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Action = "=>@R" => ActionFn(43); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action43::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant40(___nt), ___end)); (1, 62) } pub(crate) fn ___reduce103< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Action = "=>" => ActionFn(44); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action44::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant40(___nt), ___end)); (1, 62) } pub(crate) fn ___reduce104< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Action = "=>?" => ActionFn(45); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action45::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant40(___nt), ___end)); (1, 62) } pub(crate) fn ___reduce105< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Action? = Action => ActionFn(142); let ___sym0 = ___pop_Variant40(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action142::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant41(___nt), ___end)); (1, 63) } pub(crate) fn ___reduce106< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Action? = => ActionFn(143); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action143::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant41(___nt), ___end)); (0, 63) } pub(crate) fn ___reduce107< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternative = Symbol+, "if", Cond, Action => ActionFn(442); let ___sym3 = ___pop_Variant40(___symbols); let ___sym2 = ___pop_Variant7(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action442::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant10(___nt), ___end)); (4, 64) } pub(crate) fn ___reduce108< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternative = Symbol+, "if", Cond => ActionFn(443); let ___sym2 = ___pop_Variant7(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action443::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant10(___nt), ___end)); (3, 64) } pub(crate) fn ___reduce109< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternative = Symbol+, Action => ActionFn(444); let ___sym1 = ___pop_Variant40(___symbols); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action444::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant10(___nt), ___end)); (2, 64) } pub(crate) fn ___reduce110< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternative = Symbol+ => ActionFn(445); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action445::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant10(___nt), ___end)); (1, 64) } pub(crate) fn ___reduce111< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternative = "if", Cond, Action => ActionFn(419); let ___sym2 = ___pop_Variant40(___symbols); let ___sym1 = ___pop_Variant7(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action419::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant10(___nt), ___end)); (3, 64) } pub(crate) fn ___reduce112< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternative = Action => ActionFn(420); let ___sym0 = ___pop_Variant40(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action420::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant10(___nt), ___end)); (1, 64) } pub(crate) fn ___reduce113< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternative? = Alternative => ActionFn(234); let ___sym0 = ___pop_Variant10(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action234::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant42(___nt), ___end)); (1, 65) } pub(crate) fn ___reduce114< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternative? = => ActionFn(235); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action235::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant42(___nt), ___end)); (0, 65) } pub(crate) fn ___reduce115< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternatives = Alternative, ";" => ActionFn(38); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant10(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action38::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant43(___nt), ___end)); (2, 66) } pub(crate) fn ___reduce116< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternatives = "{", Comma, "}", ";" => ActionFn(300); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant43(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action300::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant43(___nt), ___end)); (4, 66) } pub(crate) fn ___reduce117< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Alternatives = "{", Comma, "}" => ActionFn(301); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant43(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action301::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant43(___nt), ___end)); (3, 66) } pub(crate) fn ___reduce118< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Annotation = "#", "[", Id, AnnotationArg, "]" => ActionFn(456); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant46(___symbols); let ___sym2 = ___pop_Variant20(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action456::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant44(___nt), ___end)); (5, 67) } pub(crate) fn ___reduce119< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Annotation = "#", "[", Id, "]" => ActionFn(457); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant20(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action457::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant44(___nt), ___end)); (4, 67) } pub(crate) fn ___reduce120< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Annotation* = => ActionFn(182); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action182::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant45(___nt), ___end)); (0, 68) } pub(crate) fn ___reduce121< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Annotation* = Annotation+ => ActionFn(183); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action183::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant45(___nt), ___end)); (1, 68) } pub(crate) fn ___reduce122< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Annotation+ = Annotation => ActionFn(192); let ___sym0 = ___pop_Variant44(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action192::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant45(___nt), ___end)); (1, 69) } pub(crate) fn ___reduce123< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Annotation+ = Annotation+, Annotation => ActionFn(193); let ___sym1 = ___pop_Variant44(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action193::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant45(___nt), ___end)); (2, 69) } pub(crate) fn ___reduce124< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // AnnotationArg = "(", Id, "=", "StringLiteral", ")" => ActionFn(33); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant1(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant20(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action33::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant46(___nt), ___end)); (5, 70) } pub(crate) fn ___reduce125< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // AnnotationArg? = AnnotationArg => ActionFn(153); let ___sym0 = ___pop_Variant46(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action153::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant47(___nt), ___end)); (1, 71) } pub(crate) fn ___reduce126< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // AnnotationArg? = => ActionFn(154); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action154::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant47(___nt), ___end)); (0, 71) } pub(crate) fn ___reduce127< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // AssociatedType = "type", Id, "=", TypeRef, ";" => ActionFn(422); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant3(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant20(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action422::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant48(___nt), ___end)); (5, 72) } pub(crate) fn ___reduce128< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // AssociatedType* = => ActionFn(127); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action127::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant49(___nt), ___end)); (0, 73) } pub(crate) fn ___reduce129< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // AssociatedType* = AssociatedType+ => ActionFn(128); let ___sym0 = ___pop_Variant49(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action128::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant49(___nt), ___end)); (1, 73) } pub(crate) fn ___reduce130< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // AssociatedType+ = AssociatedType => ActionFn(251); let ___sym0 = ___pop_Variant48(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action251::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant49(___nt), ___end)); (1, 74) } pub(crate) fn ___reduce131< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // AssociatedType+ = AssociatedType+, AssociatedType => ActionFn(252); let ___sym1 = ___pop_Variant48(___symbols); let ___sym0 = ___pop_Variant49(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action252::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant49(___nt), ___end)); (2, 74) } pub(crate) fn ___reduce132< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = Alternative => ActionFn(446); let ___sym0 = ___pop_Variant10(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action446::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant43(___nt), ___end)); (1, 75) } pub(crate) fn ___reduce133< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(447); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action447::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant43(___nt), ___end)); (0, 75) } pub(crate) fn ___reduce134< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, Alternative => ActionFn(448); let ___sym1 = ___pop_Variant10(___symbols); let ___sym0 = ___pop_Variant11(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action448::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant43(___nt), ___end)); (2, 75) } pub(crate) fn ___reduce135< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(449); let ___sym0 = ___pop_Variant11(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action449::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant43(___nt), ___end)); (1, 75) } pub(crate) fn ___reduce136< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = Conversion => ActionFn(464); let ___sym0 = ___pop_Variant12(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action464::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant50(___nt), ___end)); (1, 76) } pub(crate) fn ___reduce137< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(465); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action465::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant50(___nt), ___end)); (0, 76) } pub(crate) fn ___reduce138< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, Conversion => ActionFn(466); let ___sym1 = ___pop_Variant12(___symbols); let ___sym0 = ___pop_Variant13(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action466::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant50(___nt), ___end)); (2, 76) } pub(crate) fn ___reduce139< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(467); let ___sym0 = ___pop_Variant13(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action467::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant50(___nt), ___end)); (1, 76) } pub(crate) fn ___reduce140< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = GrammarParameter => ActionFn(490); let ___sym0 = ___pop_Variant16(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action490::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant51(___nt), ___end)); (1, 77) } pub(crate) fn ___reduce141< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(491); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action491::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant51(___nt), ___end)); (0, 77) } pub(crate) fn ___reduce142< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, GrammarParameter => ActionFn(492); let ___sym1 = ___pop_Variant16(___symbols); let ___sym0 = ___pop_Variant17(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action492::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant51(___nt), ___end)); (2, 77) } pub(crate) fn ___reduce143< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(493); let ___sym0 = ___pop_Variant17(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action493::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant51(___nt), ___end)); (1, 77) } pub(crate) fn ___reduce144< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = GrammarWhereClause => ActionFn(518); let ___sym0 = ___pop_Variant18(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action518::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant52(___nt), ___end)); (1, 78) } pub(crate) fn ___reduce145< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(519); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action519::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant52(___nt), ___end)); (0, 78) } pub(crate) fn ___reduce146< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, GrammarWhereClause => ActionFn(520); let ___sym1 = ___pop_Variant18(___symbols); let ___sym0 = ___pop_Variant19(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action520::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant52(___nt), ___end)); (2, 78) } pub(crate) fn ___reduce147< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(521); let ___sym0 = ___pop_Variant19(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action521::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant52(___nt), ___end)); (1, 78) } pub(crate) fn ___reduce148< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = MatchItem => ActionFn(562); let ___sym0 = ___pop_Variant24(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action562::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant53(___nt), ___end)); (1, 79) } pub(crate) fn ___reduce149< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(563); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action563::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant53(___nt), ___end)); (0, 79) } pub(crate) fn ___reduce150< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, MatchItem => ActionFn(564); let ___sym1 = ___pop_Variant24(___symbols); let ___sym0 = ___pop_Variant25(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action564::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant53(___nt), ___end)); (2, 79) } pub(crate) fn ___reduce151< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(565); let ___sym0 = ___pop_Variant25(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action565::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant53(___nt), ___end)); (1, 79) } pub(crate) fn ___reduce152< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = NotMacroId => ActionFn(566); let ___sym0 = ___pop_Variant26(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action566::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant54(___nt), ___end)); (1, 80) } pub(crate) fn ___reduce153< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(567); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action567::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant54(___nt), ___end)); (0, 80) } pub(crate) fn ___reduce154< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, NotMacroId => ActionFn(568); let ___sym1 = ___pop_Variant26(___symbols); let ___sym0 = ___pop_Variant27(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action568::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant54(___nt), ___end)); (2, 80) } pub(crate) fn ___reduce155< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(569); let ___sym0 = ___pop_Variant27(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action569::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant54(___nt), ___end)); (1, 80) } pub(crate) fn ___reduce156< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = Pattern => ActionFn(570); let ___sym0 = ___pop_Variant28(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action570::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant55(___nt), ___end)); (1, 81) } pub(crate) fn ___reduce157< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(571); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action571::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant55(___nt), ___end)); (0, 81) } pub(crate) fn ___reduce158< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, Pattern => ActionFn(572); let ___sym1 = ___pop_Variant28(___symbols); let ___sym0 = ___pop_Variant29(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action572::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant55(___nt), ___end)); (2, 81) } pub(crate) fn ___reduce159< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(573); let ___sym0 = ___pop_Variant29(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action573::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant55(___nt), ___end)); (1, 81) } pub(crate) fn ___reduce160< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = Symbol => ActionFn(640); let ___sym0 = ___pop_Variant30(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action640::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant56(___nt), ___end)); (1, 82) } pub(crate) fn ___reduce161< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(641); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action641::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant56(___nt), ___end)); (0, 82) } pub(crate) fn ___reduce162< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, Symbol => ActionFn(642); let ___sym1 = ___pop_Variant30(___symbols); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action642::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant56(___nt), ___end)); (2, 82) } pub(crate) fn ___reduce163< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(643); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action643::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant56(___nt), ___end)); (1, 82) } pub(crate) fn ___reduce164< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = TypeBoundParameter => ActionFn(648); let ___sym0 = ___pop_Variant34(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action648::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant5(___nt), ___end)); (1, 83) } pub(crate) fn ___reduce165< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(649); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action649::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant5(___nt), ___end)); (0, 83) } pub(crate) fn ___reduce166< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, TypeBoundParameter => ActionFn(650); let ___sym1 = ___pop_Variant34(___symbols); let ___sym0 = ___pop_Variant35(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action650::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant5(___nt), ___end)); (2, 83) } pub(crate) fn ___reduce167< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(651); let ___sym0 = ___pop_Variant35(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action651::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant5(___nt), ___end)); (1, 83) } pub(crate) fn ___reduce168< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = TypeParameter => ActionFn(652); let ___sym0 = ___pop_Variant36(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action652::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant57(___nt), ___end)); (1, 84) } pub(crate) fn ___reduce169< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(653); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action653::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant57(___nt), ___end)); (0, 84) } pub(crate) fn ___reduce170< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, TypeParameter => ActionFn(654); let ___sym1 = ___pop_Variant36(___symbols); let ___sym0 = ___pop_Variant37(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action654::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant57(___nt), ___end)); (2, 84) } pub(crate) fn ___reduce171< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(655); let ___sym0 = ___pop_Variant37(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action655::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant57(___nt), ___end)); (1, 84) } pub(crate) fn ___reduce172< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = TypeRef => ActionFn(656); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action656::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant58(___nt), ___end)); (1, 85) } pub(crate) fn ___reduce173< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(657); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action657::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant58(___nt), ___end)); (0, 85) } pub(crate) fn ___reduce174< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, TypeRef => ActionFn(658); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant38(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action658::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant58(___nt), ___end)); (2, 85) } pub(crate) fn ___reduce175< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(659); let ___sym0 = ___pop_Variant38(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action659::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant58(___nt), ___end)); (1, 85) } pub(crate) fn ___reduce176< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = TypeRefOrLifetime => ActionFn(660); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action660::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant58(___nt), ___end)); (1, 86) } pub(crate) fn ___reduce177< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = => ActionFn(661); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action661::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant58(___nt), ___end)); (0, 86) } pub(crate) fn ___reduce178< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+, TypeRefOrLifetime => ActionFn(662); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant38(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action662::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant58(___nt), ___end)); (2, 86) } pub(crate) fn ___reduce179< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Comma = ( ",")+ => ActionFn(663); let ___sym0 = ___pop_Variant38(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action663::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant58(___nt), ___end)); (1, 86) } pub(crate) fn ___reduce180< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Cond = NotMacroId, CondOp, StringLiteral => ActionFn(423); let ___sym2 = ___pop_Variant20(___symbols); let ___sym1 = ___pop_Variant59(___symbols); let ___sym0 = ___pop_Variant26(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action423::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant7(___nt), ___end)); (3, 87) } pub(crate) fn ___reduce181< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // CondOp = "==" => ActionFn(47); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action47::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant59(___nt), ___end)); (1, 88) } pub(crate) fn ___reduce182< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // CondOp = "!=" => ActionFn(48); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action48::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant59(___nt), ___end)); (1, 88) } pub(crate) fn ___reduce183< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // CondOp = "~~" => ActionFn(49); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action49::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant59(___nt), ___end)); (1, 88) } pub(crate) fn ___reduce184< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // CondOp = "!~" => ActionFn(50); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action50::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant59(___nt), ___end)); (1, 88) } pub(crate) fn ___reduce186< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Conversion? = Conversion => ActionFn(258); let ___sym0 = ___pop_Variant12(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action258::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant60(___nt), ___end)); (1, 90) } pub(crate) fn ___reduce187< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Conversion? = => ActionFn(259); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action259::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant60(___nt), ___end)); (0, 90) } pub(crate) fn ___reduce188< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // EnumToken = "enum", TypeRef, "{", Comma, "}" => ActionFn(425); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant50(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action425::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant61(___nt), ___end)); (5, 91) } pub(crate) fn ___reduce189< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Escape = "Escape" => ActionFn(109); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action109::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant20(___nt), ___end)); (1, 92) } pub(crate) fn ___reduce190< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ExprSymbol = => ActionFn(638); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action638::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant62(___nt), ___end)); (0, 93) } pub(crate) fn ___reduce191< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ExprSymbol = Symbol+ => ActionFn(639); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action639::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant62(___nt), ___end)); (1, 93) } pub(crate) fn ___reduce192< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ExternToken = "extern", "{", EnumToken, "}" => ActionFn(458); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant61(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action458::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (4, 94) } pub(crate) fn ___reduce193< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ExternToken = "extern", "{", EnumToken, AssociatedType+, "}" => ActionFn(459); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant49(___symbols); let ___sym2 = ___pop_Variant61(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action459::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (5, 94) } pub(crate) fn ___reduce194< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ExternToken = "extern", "{", AssociatedType+, EnumToken, "}" => ActionFn(460); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant61(___symbols); let ___sym2 = ___pop_Variant49(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action460::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (5, 94) } pub(crate) fn ___reduce195< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ExternToken = "extern", "{", AssociatedType+, EnumToken, AssociatedType+, "}" => ActionFn(461); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant49(___symbols); let ___sym3 = ___pop_Variant61(___symbols); let ___sym2 = ___pop_Variant49(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action461::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (6, 94) } pub(crate) fn ___reduce196< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ExternToken = "extern", "{", "}" => ActionFn(462); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action462::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (3, 94) } pub(crate) fn ___reduce197< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ExternToken = "extern", "{", AssociatedType+, "}" => ActionFn(463); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant49(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action463::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (4, 94) } pub(crate) fn ___reduce198< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // FieldPattern = Id, ":", Pattern => ActionFn(428); let ___sym2 = ___pop_Variant28(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action428::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant14(___nt), ___end)); (3, 95) } pub(crate) fn ___reduce199< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // FieldPattern? = FieldPattern => ActionFn(119); let ___sym0 = ___pop_Variant14(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action119::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant64(___nt), ___end)); (1, 96) } pub(crate) fn ___reduce200< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // FieldPattern? = => ActionFn(120); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action120::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant64(___nt), ___end)); (0, 96) } pub(crate) fn ___reduce201< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ForAll = "for", "<", Comma, ">" => ActionFn(13); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action13::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant57(___nt), ___end)); (4, 97) } pub(crate) fn ___reduce202< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ForAll = => ActionFn(322); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action322::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant57(___nt), ___end)); (0, 97) } pub(crate) fn ___reduce203< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";" => ActionFn(664); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant57(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action664::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce204< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";" => ActionFn(665); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action665::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce205< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";" => ActionFn(666); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action666::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce206< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";" => ActionFn(667); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action667::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce207< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarTypeParameters, GrammarParameters, ";" => ActionFn(668); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant57(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action668::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce208< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarTypeParameters, GrammarParameters, ";" => ActionFn(669); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action669::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce209< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarTypeParameters, GrammarParameters, ";" => ActionFn(670); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action670::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce210< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarTypeParameters, GrammarParameters, ";" => ActionFn(671); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action671::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce211< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarParameters, GrammarWhereClauses, ";" => ActionFn(672); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant51(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action672::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce212< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarParameters, GrammarWhereClauses, ";" => ActionFn(673); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action673::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce213< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarParameters, GrammarWhereClauses, ";" => ActionFn(674); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action674::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce214< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarParameters, GrammarWhereClauses, ";" => ActionFn(675); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action675::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce215< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarParameters, ";" => ActionFn(676); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant51(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action676::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (3, 98) } pub(crate) fn ___reduce216< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarParameters, ";" => ActionFn(677); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action677::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce217< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarParameters, ";" => ActionFn(678); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action678::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce218< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarParameters, ";" => ActionFn(679); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action679::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce219< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarTypeParameters, GrammarWhereClauses, ";" => ActionFn(680); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant57(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action680::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce220< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";" => ActionFn(681); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action681::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce221< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";" => ActionFn(682); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action682::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce222< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";" => ActionFn(683); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action683::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce223< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarTypeParameters, ";" => ActionFn(684); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant57(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action684::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (3, 98) } pub(crate) fn ___reduce224< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarTypeParameters, ";" => ActionFn(685); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action685::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce225< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarTypeParameters, ";" => ActionFn(686); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action686::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce226< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarTypeParameters, ";" => ActionFn(687); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action687::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce227< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarWhereClauses, ";" => ActionFn(688); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant52(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action688::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (3, 98) } pub(crate) fn ___reduce228< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarWhereClauses, ";" => ActionFn(689); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action689::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce229< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarWhereClauses, ";" => ActionFn(690); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action690::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce230< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarWhereClauses, ";" => ActionFn(691); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action691::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce231< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", ";" => ActionFn(692); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action692::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (2, 98) } pub(crate) fn ___reduce232< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", ";" => ActionFn(693); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action693::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (3, 98) } pub(crate) fn ___reduce233< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", ";" => ActionFn(694); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action694::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (3, 98) } pub(crate) fn ___reduce234< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", ";" => ActionFn(695); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action695::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce235< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(696); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant57(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action696::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce236< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(697); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action697::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce237< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(698); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action698::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce238< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(699); let ___sym7 = ___pop_Variant66(___symbols); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym7.2.clone(); let ___nt = super::___action699::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (8, 98) } pub(crate) fn ___reduce239< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarTypeParameters, GrammarParameters, ";", GrammarItem+ => ActionFn(700); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant57(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action700::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce240< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarTypeParameters, GrammarParameters, ";", GrammarItem+ => ActionFn(701); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action701::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce241< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarTypeParameters, GrammarParameters, ";", GrammarItem+ => ActionFn(702); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action702::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce242< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarTypeParameters, GrammarParameters, ";", GrammarItem+ => ActionFn(703); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action703::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce243< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(704); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant51(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action704::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce244< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(705); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action705::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce245< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(706); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action706::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce246< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(707); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action707::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce247< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarParameters, ";", GrammarItem+ => ActionFn(708); let ___sym3 = ___pop_Variant66(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant51(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action708::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce248< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarParameters, ";", GrammarItem+ => ActionFn(709); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action709::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce249< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarParameters, ";", GrammarItem+ => ActionFn(710); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action710::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce250< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarParameters, ";", GrammarItem+ => ActionFn(711); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action711::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce251< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarTypeParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(712); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant57(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action712::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce252< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(713); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action713::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce253< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(714); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action714::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce254< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(715); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action715::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce255< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarTypeParameters, ";", GrammarItem+ => ActionFn(716); let ___sym3 = ___pop_Variant66(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant57(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action716::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce256< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarTypeParameters, ";", GrammarItem+ => ActionFn(717); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action717::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce257< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarTypeParameters, ";", GrammarItem+ => ActionFn(718); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action718::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce258< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarTypeParameters, ";", GrammarItem+ => ActionFn(719); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action719::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce259< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", GrammarWhereClauses, ";", GrammarItem+ => ActionFn(720); let ___sym3 = ___pop_Variant66(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant52(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action720::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce260< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", GrammarWhereClauses, ";", GrammarItem+ => ActionFn(721); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action721::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce261< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", GrammarWhereClauses, ";", GrammarItem+ => ActionFn(722); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action722::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce262< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", GrammarWhereClauses, ";", GrammarItem+ => ActionFn(723); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action723::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce263< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = "grammar", ";", GrammarItem+ => ActionFn(724); let ___sym2 = ___pop_Variant66(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action724::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (3, 98) } pub(crate) fn ___reduce264< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, "grammar", ";", GrammarItem+ => ActionFn(725); let ___sym3 = ___pop_Variant66(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action725::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce265< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, "grammar", ";", GrammarItem+ => ActionFn(726); let ___sym3 = ___pop_Variant66(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action726::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce266< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, "grammar", ";", GrammarItem+ => ActionFn(727); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action727::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce267< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";" => ActionFn(728); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action728::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce268< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";" => ActionFn(729); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action729::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce269< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";" => ActionFn(730); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action730::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce270< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";" => ActionFn(731); let ___sym7 = ___pop_Variant0(___symbols); let ___sym6 = ___pop_Variant52(___symbols); let ___sym5 = ___pop_Variant51(___symbols); let ___sym4 = ___pop_Variant57(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym7.2.clone(); let ___nt = super::___action731::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (8, 98) } pub(crate) fn ___reduce271< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, ";" => ActionFn(732); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action732::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce272< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, ";" => ActionFn(733); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action733::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce273< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, ";" => ActionFn(734); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action734::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce274< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, ";" => ActionFn(735); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant51(___symbols); let ___sym4 = ___pop_Variant57(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action735::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce275< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarParameters, GrammarWhereClauses, ";" => ActionFn(736); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action736::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce276< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarParameters, GrammarWhereClauses, ";" => ActionFn(737); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action737::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce277< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarParameters, GrammarWhereClauses, ";" => ActionFn(738); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action738::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce278< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarParameters, GrammarWhereClauses, ";" => ActionFn(739); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action739::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce279< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarParameters, ";" => ActionFn(740); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action740::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce280< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarParameters, ";" => ActionFn(741); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action741::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce281< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarParameters, ";" => ActionFn(742); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action742::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce282< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarParameters, ";" => ActionFn(743); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action743::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce283< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";" => ActionFn(744); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action744::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce284< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";" => ActionFn(745); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action745::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce285< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";" => ActionFn(746); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action746::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce286< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";" => ActionFn(747); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant57(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action747::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce287< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarTypeParameters, ";" => ActionFn(748); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action748::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce288< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarTypeParameters, ";" => ActionFn(749); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action749::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce289< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarTypeParameters, ";" => ActionFn(750); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action750::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce290< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarTypeParameters, ";" => ActionFn(751); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant57(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action751::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce291< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarWhereClauses, ";" => ActionFn(752); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action752::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce292< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarWhereClauses, ";" => ActionFn(753); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action753::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce293< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarWhereClauses, ";" => ActionFn(754); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action754::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce294< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarWhereClauses, ";" => ActionFn(755); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action755::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce295< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", ";" => ActionFn(756); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action756::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (3, 98) } pub(crate) fn ___reduce296< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", ";" => ActionFn(757); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action757::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce297< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", ";" => ActionFn(758); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action758::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce298< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", ";" => ActionFn(759); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action759::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce299< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(760); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action760::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce300< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(761); let ___sym7 = ___pop_Variant66(___symbols); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym7.2.clone(); let ___nt = super::___action761::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (8, 98) } pub(crate) fn ___reduce301< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(762); let ___sym7 = ___pop_Variant66(___symbols); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym7.2.clone(); let ___nt = super::___action762::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (8, 98) } pub(crate) fn ___reduce302< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(763); let ___sym8 = ___pop_Variant66(___symbols); let ___sym7 = ___pop_Variant0(___symbols); let ___sym6 = ___pop_Variant52(___symbols); let ___sym5 = ___pop_Variant51(___symbols); let ___sym4 = ___pop_Variant57(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym8.2.clone(); let ___nt = super::___action763::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7, ___sym8); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (9, 98) } pub(crate) fn ___reduce303< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, ";", GrammarItem+ => ActionFn(764); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action764::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce304< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, ";", GrammarItem+ => ActionFn(765); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action765::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce305< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, ";", GrammarItem+ => ActionFn(766); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action766::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce306< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarParameters, ";", GrammarItem+ => ActionFn(767); let ___sym7 = ___pop_Variant66(___symbols); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant51(___symbols); let ___sym4 = ___pop_Variant57(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym7.2.clone(); let ___nt = super::___action767::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (8, 98) } pub(crate) fn ___reduce307< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(768); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action768::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce308< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(769); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action769::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce309< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(770); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action770::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce310< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(771); let ___sym7 = ___pop_Variant66(___symbols); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym7.2.clone(); let ___nt = super::___action771::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (8, 98) } pub(crate) fn ___reduce311< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarParameters, ";", GrammarItem+ => ActionFn(772); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant51(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action772::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce312< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarParameters, ";", GrammarItem+ => ActionFn(773); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action773::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce313< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarParameters, ";", GrammarItem+ => ActionFn(774); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant51(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action774::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce314< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarParameters, ";", GrammarItem+ => ActionFn(775); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant51(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action775::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce315< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(776); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action776::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce316< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(777); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action777::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce317< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(778); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action778::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce318< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarTypeParameters, GrammarWhereClauses, ";", GrammarItem+ => ActionFn(779); let ___sym7 = ___pop_Variant66(___symbols); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant52(___symbols); let ___sym4 = ___pop_Variant57(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym7.2.clone(); let ___nt = super::___action779::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (8, 98) } pub(crate) fn ___reduce319< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarTypeParameters, ";", GrammarItem+ => ActionFn(780); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action780::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce320< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarTypeParameters, ";", GrammarItem+ => ActionFn(781); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action781::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce321< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarTypeParameters, ";", GrammarItem+ => ActionFn(782); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action782::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce322< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarTypeParameters, ";", GrammarItem+ => ActionFn(783); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant57(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action783::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce323< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", GrammarWhereClauses, ";", GrammarItem+ => ActionFn(784); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant52(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action784::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce324< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", GrammarWhereClauses, ";", GrammarItem+ => ActionFn(785); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action785::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce325< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", GrammarWhereClauses, ";", GrammarItem+ => ActionFn(786); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant52(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action786::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce326< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", GrammarWhereClauses, ";", GrammarItem+ => ActionFn(787); let ___sym6 = ___pop_Variant66(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant52(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action787::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (7, 98) } pub(crate) fn ___reduce327< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Annotation+, "grammar", ";", GrammarItem+ => ActionFn(788); let ___sym3 = ___pop_Variant66(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action788::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (4, 98) } pub(crate) fn ___reduce328< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = Use+, Annotation+, "grammar", ";", GrammarItem+ => ActionFn(789); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action789::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce329< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Annotation+, "grammar", ";", GrammarItem+ => ActionFn(790); let ___sym4 = ___pop_Variant66(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant45(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action790::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (5, 98) } pub(crate) fn ___reduce330< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Grammar = ShebangAttribute+, Use+, Annotation+, "grammar", ";", GrammarItem+ => ActionFn(791); let ___sym5 = ___pop_Variant66(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant45(___symbols); let ___sym1 = ___pop_Variant66(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action791::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant65(___nt), ___end)); (6, 98) } pub(crate) fn ___reduce331< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarItem = Use => ActionFn(24); let ___sym0 = ___pop_Variant63(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action24::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (1, 99) } pub(crate) fn ___reduce332< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarItem = MatchToken => ActionFn(25); let ___sym0 = ___pop_Variant63(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action25::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (1, 99) } pub(crate) fn ___reduce333< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarItem = ExternToken => ActionFn(26); let ___sym0 = ___pop_Variant63(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action26::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (1, 99) } pub(crate) fn ___reduce334< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarItem = Nonterminal => ActionFn(27); let ___sym0 = ___pop_Variant63(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action27::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (1, 99) } pub(crate) fn ___reduce335< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarItem* = => ActionFn(172); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action172::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant66(___nt), ___end)); (0, 100) } pub(crate) fn ___reduce336< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarItem* = GrammarItem+ => ActionFn(173); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action173::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant66(___nt), ___end)); (1, 100) } pub(crate) fn ___reduce337< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarItem+ = GrammarItem => ActionFn(194); let ___sym0 = ___pop_Variant63(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action194::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant66(___nt), ___end)); (1, 101) } pub(crate) fn ___reduce338< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarItem+ = GrammarItem+, GrammarItem => ActionFn(195); let ___sym1 = ___pop_Variant63(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action195::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant66(___nt), ___end)); (2, 101) } pub(crate) fn ___reduce339< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarParameter = Id, ":", TypeRef => ActionFn(23); let ___sym2 = ___pop_Variant3(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action23::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant16(___nt), ___end)); (3, 102) } pub(crate) fn ___reduce340< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarParameter? = GrammarParameter => ActionFn(224); let ___sym0 = ___pop_Variant16(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action224::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant67(___nt), ___end)); (1, 103) } pub(crate) fn ___reduce341< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarParameter? = => ActionFn(225); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action225::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant67(___nt), ___end)); (0, 103) } pub(crate) fn ___reduce342< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarParameters = "(", Comma, ")" => ActionFn(22); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant51(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action22::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant51(___nt), ___end)); (3, 104) } pub(crate) fn ___reduce343< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarParameters? = GrammarParameters => ActionFn(176); let ___sym0 = ___pop_Variant51(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action176::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant68(___nt), ___end)); (1, 105) } pub(crate) fn ___reduce344< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarParameters? = => ActionFn(177); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action177::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant68(___nt), ___end)); (0, 105) } pub(crate) fn ___reduce345< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarTypeParameters = "<", Comma, ">" => ActionFn(7); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant57(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action7::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant57(___nt), ___end)); (3, 106) } pub(crate) fn ___reduce346< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarTypeParameters? = GrammarTypeParameters => ActionFn(178); let ___sym0 = ___pop_Variant57(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action178::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant69(___nt), ___end)); (1, 107) } pub(crate) fn ___reduce347< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarTypeParameters? = => ActionFn(179); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action179::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant69(___nt), ___end)); (0, 107) } pub(crate) fn ___reduce348< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarWhereClause = Lifetime, ":", Plus => ActionFn(11); let ___sym2 = ___pop_Variant83(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant22(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action11::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant18(___nt), ___end)); (3, 108) } pub(crate) fn ___reduce349< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarWhereClause = "for", "<", Comma, ">", TypeRef, ":", TypeBounds => ActionFn(472); let ___sym6 = ___pop_Variant84(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant3(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action472::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant18(___nt), ___end)); (7, 108) } pub(crate) fn ___reduce350< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarWhereClause = TypeRef, ":", TypeBounds => ActionFn(473); let ___sym2 = ___pop_Variant84(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action473::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant18(___nt), ___end)); (3, 108) } pub(crate) fn ___reduce351< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarWhereClause? = GrammarWhereClause => ActionFn(201); let ___sym0 = ___pop_Variant18(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action201::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant70(___nt), ___end)); (1, 109) } pub(crate) fn ___reduce352< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarWhereClause? = => ActionFn(202); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action202::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant70(___nt), ___end)); (0, 109) } pub(crate) fn ___reduce353< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarWhereClauses = "where", Comma => ActionFn(10); let ___sym1 = ___pop_Variant52(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action10::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant52(___nt), ___end)); (2, 110) } pub(crate) fn ___reduce354< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarWhereClauses? = GrammarWhereClauses => ActionFn(174); let ___sym0 = ___pop_Variant52(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action174::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant71(___nt), ___end)); (1, 111) } pub(crate) fn ___reduce355< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // GrammarWhereClauses? = => ActionFn(175); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action175::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant71(___nt), ___end)); (0, 111) } pub(crate) fn ___reduce356< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Id = "Id" => ActionFn(107); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action107::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant20(___nt), ___end)); (1, 112) } pub(crate) fn ___reduce357< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Id = "MacroId" => ActionFn(108); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action108::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant20(___nt), ___end)); (1, 112) } pub(crate) fn ___reduce358< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Lifetime = "Lifetime" => ActionFn(110); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action110::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant22(___nt), ___end)); (1, 113) } pub(crate) fn ___reduce359< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Lifetime? = Lifetime => ActionFn(135); let ___sym0 = ___pop_Variant22(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action135::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant72(___nt), ___end)); (1, 114) } pub(crate) fn ___reduce360< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Lifetime? = => ActionFn(136); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action136::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant72(___nt), ___end)); (0, 114) } pub(crate) fn ___reduce361< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MacroId = "MacroId" => ActionFn(105); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action105::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant26(___nt), ___end)); (1, 115) } pub(crate) fn ___reduce362< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchContents = Comma => ActionFn(85); let ___sym0 = ___pop_Variant53(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action85::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant73(___nt), ___end)); (1, 116) } pub(crate) fn ___reduce363< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchItem = "_" => ActionFn(430); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action430::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant24(___nt), ___end)); (1, 117) } pub(crate) fn ___reduce364< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchItem = MatchSymbol => ActionFn(431); let ___sym0 = ___pop_Variant76(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action431::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant24(___nt), ___end)); (1, 117) } pub(crate) fn ___reduce366< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchItem? = MatchItem => ActionFn(253); let ___sym0 = ___pop_Variant24(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action253::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant74(___nt), ___end)); (1, 118) } pub(crate) fn ___reduce367< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchItem? = => ActionFn(254); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action254::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant74(___nt), ___end)); (0, 118) } pub(crate) fn ___reduce368< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchMapping = Terminal => ActionFn(90); let ___sym0 = ___pop_Variant75(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action90::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant75(___nt), ___end)); (1, 119) } pub(crate) fn ___reduce369< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchSymbol = QuotedLiteral => ActionFn(89); let ___sym0 = ___pop_Variant76(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action89::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant76(___nt), ___end)); (1, 120) } pub(crate) fn ___reduce370< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchToken = MatchTokenInt => ActionFn(82); let ___sym0 = ___pop_Variant77(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action82::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (1, 121) } pub(crate) fn ___reduce371< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchTokenInt = MatchTokenInt, "else", "{", MatchContents, "}" => ActionFn(83); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant73(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant77(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action83::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant77(___nt), ___end)); (5, 122) } pub(crate) fn ___reduce372< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // MatchTokenInt = "match", "{", MatchContents, "}" => ActionFn(433); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant73(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action433::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant77(___nt), ___end)); (4, 122) } pub(crate) fn ___reduce373< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Nonterminal = Visibility, NonterminalName, ":", TypeRef, "=", Alternatives => ActionFn(452); let ___sym5 = ___pop_Variant43(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant3(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant78(___symbols); let ___sym0 = ___pop_Variant94(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action452::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (6, 123) } pub(crate) fn ___reduce374< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Nonterminal = Annotation+, Visibility, NonterminalName, ":", TypeRef, "=", Alternatives => ActionFn(453); let ___sym6 = ___pop_Variant43(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant3(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant78(___symbols); let ___sym1 = ___pop_Variant94(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action453::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (7, 123) } pub(crate) fn ___reduce375< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Nonterminal = Visibility, NonterminalName, "=", Alternatives => ActionFn(454); let ___sym3 = ___pop_Variant43(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant78(___symbols); let ___sym0 = ___pop_Variant94(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action454::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (4, 123) } pub(crate) fn ___reduce376< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Nonterminal = Annotation+, Visibility, NonterminalName, "=", Alternatives => ActionFn(455); let ___sym4 = ___pop_Variant43(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant78(___symbols); let ___sym1 = ___pop_Variant94(___symbols); let ___sym0 = ___pop_Variant45(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action455::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (5, 123) } pub(crate) fn ___reduce377< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // NonterminalName = MacroId, "<", Comma, ">" => ActionFn(35); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant54(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant26(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action35::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant78(___nt), ___end)); (4, 124) } pub(crate) fn ___reduce378< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // NonterminalName = NotMacroId => ActionFn(36); let ___sym0 = ___pop_Variant26(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action36::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant78(___nt), ___end)); (1, 124) } pub(crate) fn ___reduce379< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // NonterminalName = "Escape" => ActionFn(37); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action37::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant78(___nt), ___end)); (1, 124) } pub(crate) fn ___reduce380< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // NotMacroId = "Id" => ActionFn(106); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action106::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant26(___nt), ___end)); (1, 125) } pub(crate) fn ___reduce381< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // NotMacroId? = NotMacroId => ActionFn(229); let ___sym0 = ___pop_Variant26(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action229::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant79(___nt), ___end)); (1, 126) } pub(crate) fn ___reduce382< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // NotMacroId? = => ActionFn(230); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action230::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant79(___nt), ___end)); (0, 126) } pub(crate) fn ___reduce383< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Path = "::", Id => ActionFn(348); let ___sym1 = ___pop_Variant20(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action348::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant80(___nt), ___end)); (2, 127) } pub(crate) fn ___reduce384< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Path = "::", ( "::")+, Id => ActionFn(349); let ___sym2 = ___pop_Variant20(___symbols); let ___sym1 = ___pop_Variant21(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action349::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant80(___nt), ___end)); (3, 127) } pub(crate) fn ___reduce385< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Path = Id => ActionFn(350); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action350::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant80(___nt), ___end)); (1, 127) } pub(crate) fn ___reduce386< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Path = ( "::")+, Id => ActionFn(351); let ___sym1 = ___pop_Variant20(___symbols); let ___sym0 = ___pop_Variant21(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action351::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant80(___nt), ___end)); (2, 127) } pub(crate) fn ___reduce387< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Pattern = PatternKind => ActionFn(436); let ___sym0 = ___pop_Variant82(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action436::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant28(___nt), ___end)); (1, 128) } pub(crate) fn ___reduce388< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Pattern? = Pattern => ActionFn(263); let ___sym0 = ___pop_Variant28(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action263::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant81(___nt), ___end)); (1, 129) } pub(crate) fn ___reduce389< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Pattern? = => ActionFn(264); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action264::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant81(___nt), ___end)); (0, 129) } pub(crate) fn ___reduce390< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = Path, "(", Comma, ")" => ActionFn(95); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant55(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action95::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (4, 130) } pub(crate) fn ___reduce391< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = Path, "{", FieldPattern, "}" => ActionFn(468); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant14(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action468::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (4, 130) } pub(crate) fn ___reduce392< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = Path, "{", "}" => ActionFn(469); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action469::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (3, 130) } pub(crate) fn ___reduce393< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = Path, "{", ( ",")+, FieldPattern, "}" => ActionFn(470); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant14(___symbols); let ___sym2 = ___pop_Variant15(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action470::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (5, 130) } pub(crate) fn ___reduce394< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = Path, "{", ( ",")+, "}" => ActionFn(471); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant15(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action471::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (4, 130) } pub(crate) fn ___reduce395< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = Path, "{", "..", "}" => ActionFn(336); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action336::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (4, 130) } pub(crate) fn ___reduce396< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = Path, "{", ( ",")+, "..", "}" => ActionFn(337); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant15(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action337::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (5, 130) } pub(crate) fn ___reduce397< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = "_" => ActionFn(98); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action98::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (1, 130) } pub(crate) fn ___reduce398< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = ".." => ActionFn(99); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action99::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (1, 130) } pub(crate) fn ___reduce399< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = "<", TypeRef, ">" => ActionFn(100); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action100::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (3, 130) } pub(crate) fn ___reduce400< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = "(", Comma, ")" => ActionFn(101); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant55(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action101::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (3, 130) } pub(crate) fn ___reduce401< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = "CharLiteral" => ActionFn(102); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action102::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (1, 130) } pub(crate) fn ___reduce402< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // PatternKind = Path => ActionFn(103); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action103::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant82(___nt), ___end)); (1, 130) } pub(crate) fn ___reduce403< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Plus = Lifetime => ActionFn(554); let ___sym0 = ___pop_Variant22(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action554::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant83(___nt), ___end)); (1, 131) } pub(crate) fn ___reduce404< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Plus = => ActionFn(555); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action555::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant83(___nt), ___end)); (0, 131) } pub(crate) fn ___reduce405< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Plus = ( "+")+, Lifetime => ActionFn(556); let ___sym1 = ___pop_Variant22(___symbols); let ___sym0 = ___pop_Variant23(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action556::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant83(___nt), ___end)); (2, 131) } pub(crate) fn ___reduce406< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Plus = ( "+")+ => ActionFn(557); let ___sym0 = ___pop_Variant23(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action557::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant83(___nt), ___end)); (1, 131) } pub(crate) fn ___reduce407< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Plus = TypeBound => ActionFn(644); let ___sym0 = ___pop_Variant32(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action644::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant84(___nt), ___end)); (1, 132) } pub(crate) fn ___reduce408< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Plus = => ActionFn(645); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action645::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant84(___nt), ___end)); (0, 132) } pub(crate) fn ___reduce409< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Plus = ( "+")+, TypeBound => ActionFn(646); let ___sym1 = ___pop_Variant32(___symbols); let ___sym0 = ___pop_Variant33(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action646::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant84(___nt), ___end)); (2, 132) } pub(crate) fn ___reduce410< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Plus = ( "+")+ => ActionFn(647); let ___sym0 = ___pop_Variant33(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action647::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant84(___nt), ___end)); (1, 132) } pub(crate) fn ___reduce411< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // QuotedLiteral = StringLiteral => ActionFn(114); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action114::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant76(___nt), ___end)); (1, 133) } pub(crate) fn ___reduce412< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // QuotedLiteral = RegexLiteral => ActionFn(115); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action115::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant76(___nt), ___end)); (1, 133) } pub(crate) fn ___reduce413< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // QuotedTerminal = QuotedLiteral => ActionFn(113); let ___sym0 = ___pop_Variant76(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action113::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant75(___nt), ___end)); (1, 134) } pub(crate) fn ___reduce414< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // RegexLiteral = "RegexLiteral" => ActionFn(117); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action117::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant20(___nt), ___end)); (1, 135) } pub(crate) fn ___reduce415< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // RepeatOp = "+" => ActionFn(57); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action57::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant85(___nt), ___end)); (1, 136) } pub(crate) fn ___reduce416< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // RepeatOp = "*" => ActionFn(58); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action58::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant85(___nt), ___end)); (1, 136) } pub(crate) fn ___reduce417< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // RepeatOp = "?" => ActionFn(59); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action59::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant85(___nt), ___end)); (1, 136) } pub(crate) fn ___reduce418< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ShebangAttribute = "#![...]" => ActionFn(118); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action118::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant86(___nt), ___end)); (1, 137) } pub(crate) fn ___reduce419< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ShebangAttribute* = => ActionFn(186); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action186::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant87(___nt), ___end)); (0, 138) } pub(crate) fn ___reduce420< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ShebangAttribute* = ShebangAttribute+ => ActionFn(187); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action187::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant87(___nt), ___end)); (1, 138) } pub(crate) fn ___reduce421< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ShebangAttribute+ = ShebangAttribute => ActionFn(188); let ___sym0 = ___pop_Variant86(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action188::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant87(___nt), ___end)); (1, 139) } pub(crate) fn ___reduce422< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // ShebangAttribute+ = ShebangAttribute+, ShebangAttribute => ActionFn(189); let ___sym1 = ___pop_Variant86(___symbols); let ___sym0 = ___pop_Variant87(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action189::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant87(___nt), ___end)); (2, 139) } pub(crate) fn ___reduce424< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol = "<", "mut", Id, ":", Symbol0, ">" => ActionFn(437); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant30(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant20(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action437::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant30(___nt), ___end)); (6, 141) } pub(crate) fn ___reduce425< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol = "<", Id, ":", Symbol0, ">" => ActionFn(438); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant30(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant20(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action438::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant30(___nt), ___end)); (5, 141) } pub(crate) fn ___reduce426< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol = "<", Symbol0, ">" => ActionFn(439); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant30(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action439::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant30(___nt), ___end)); (3, 141) } pub(crate) fn ___reduce427< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol = Symbol0 => ActionFn(54); let ___sym0 = ___pop_Variant30(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action54::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant30(___nt), ___end)); (1, 141) } pub(crate) fn ___reduce428< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol* = => ActionFn(140); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action140::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant31(___nt), ___end)); (0, 142) } pub(crate) fn ___reduce429< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol* = Symbol+ => ActionFn(141); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action141::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant31(___nt), ___end)); (1, 142) } pub(crate) fn ___reduce430< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol+ = Symbol => ActionFn(147); let ___sym0 = ___pop_Variant30(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action147::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant31(___nt), ___end)); (1, 143) } pub(crate) fn ___reduce431< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol+ = Symbol+, Symbol => ActionFn(148); let ___sym1 = ___pop_Variant30(___symbols); let ___sym0 = ___pop_Variant31(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action148::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant31(___nt), ___end)); (2, 143) } pub(crate) fn ___reduce432< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol0 = Symbol1 => ActionFn(55); let ___sym0 = ___pop_Variant30(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action55::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant30(___nt), ___end)); (1, 144) } pub(crate) fn ___reduce433< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol0 = Symbol0, RepeatOp => ActionFn(440); let ___sym1 = ___pop_Variant85(___symbols); let ___sym0 = ___pop_Variant30(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action440::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant30(___nt), ___end)); (2, 144) } pub(crate) fn ___reduce434< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol1 = SymbolKind1 => ActionFn(441); let ___sym0 = ___pop_Variant89(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action441::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant30(___nt), ___end)); (1, 145) } pub(crate) fn ___reduce435< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol? = Symbol => ActionFn(239); let ___sym0 = ___pop_Variant30(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action239::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant88(___nt), ___end)); (1, 146) } pub(crate) fn ___reduce436< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Symbol? = => ActionFn(240); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action240::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant88(___nt), ___end)); (0, 146) } pub(crate) fn ___reduce437< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // SymbolKind1 = MacroId, "<", Comma, ">" => ActionFn(61); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant56(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant26(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action61::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant89(___nt), ___end)); (4, 147) } pub(crate) fn ___reduce438< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // SymbolKind1 = QuotedTerminal => ActionFn(62); let ___sym0 = ___pop_Variant75(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action62::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant89(___nt), ___end)); (1, 147) } pub(crate) fn ___reduce439< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // SymbolKind1 = "Id" => ActionFn(63); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action63::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant89(___nt), ___end)); (1, 147) } pub(crate) fn ___reduce440< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // SymbolKind1 = Escape => ActionFn(64); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action64::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant89(___nt), ___end)); (1, 147) } pub(crate) fn ___reduce441< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // SymbolKind1 = "(", ExprSymbol, ")" => ActionFn(65); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant62(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action65::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant89(___nt), ___end)); (3, 147) } pub(crate) fn ___reduce442< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // SymbolKind1 = "@L" => ActionFn(66); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action66::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant89(___nt), ___end)); (1, 147) } pub(crate) fn ___reduce443< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // SymbolKind1 = "@R" => ActionFn(67); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action67::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant89(___nt), ___end)); (1, 147) } pub(crate) fn ___reduce444< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // SymbolKind1 = "!" => ActionFn(68); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action68::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant89(___nt), ___end)); (1, 147) } pub(crate) fn ___reduce445< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Terminal = QuotedTerminal => ActionFn(111); let ___sym0 = ___pop_Variant75(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action111::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant75(___nt), ___end)); (1, 148) } pub(crate) fn ___reduce446< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Terminal = "Id" => ActionFn(112); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action112::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant75(___nt), ___end)); (1, 148) } pub(crate) fn ___reduce447< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Top = "StartGrammar", Grammar => ActionFn(1); let ___sym1 = ___pop_Variant65(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action1::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant90(___nt), ___end)); (2, 149) } pub(crate) fn ___reduce448< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Top = "StartPattern", Pattern => ActionFn(2); let ___sym1 = ___pop_Variant28(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action2::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant90(___nt), ___end)); (2, 149) } pub(crate) fn ___reduce449< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Top = "StartMatchMapping", MatchMapping => ActionFn(3); let ___sym1 = ___pop_Variant75(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action3::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant90(___nt), ___end)); (2, 149) } pub(crate) fn ___reduce450< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Top = "StartTypeRef", TypeRef => ActionFn(4); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action4::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant90(___nt), ___end)); (2, 149) } pub(crate) fn ___reduce451< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Top = "StartGrammarWhereClauses", GrammarWhereClauses => ActionFn(5); let ___sym1 = ___pop_Variant52(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action5::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant90(___nt), ___end)); (2, 149) } pub(crate) fn ___reduce452< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound = Lifetime => ActionFn(16); let ___sym0 = ___pop_Variant22(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action16::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (1, 150) } pub(crate) fn ___reduce453< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound = "for", "<", Comma, ">", Path, "(", Comma, ")", "->", TypeRef => ActionFn(474); let ___sym9 = ___pop_Variant3(___symbols); let ___sym8 = ___pop_Variant0(___symbols); let ___sym7 = ___pop_Variant0(___symbols); let ___sym6 = ___pop_Variant58(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant80(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym9.2.clone(); let ___nt = super::___action474::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7, ___sym8, ___sym9); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (10, 150) } pub(crate) fn ___reduce454< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound = Path, "(", Comma, ")", "->", TypeRef => ActionFn(475); let ___sym5 = ___pop_Variant3(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant58(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym5.2.clone(); let ___nt = super::___action475::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (6, 150) } pub(crate) fn ___reduce455< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound = "for", "<", Comma, ">", Path, "(", Comma, ")" => ActionFn(476); let ___sym7 = ___pop_Variant0(___symbols); let ___sym6 = ___pop_Variant58(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant80(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym7.2.clone(); let ___nt = super::___action476::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (8, 150) } pub(crate) fn ___reduce456< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound = Path, "(", Comma, ")" => ActionFn(477); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant58(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action477::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (4, 150) } pub(crate) fn ___reduce457< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound = "for", "<", Comma, ">", Path, "<", Comma, ">" => ActionFn(478); let ___sym7 = ___pop_Variant0(___symbols); let ___sym6 = ___pop_Variant5(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant80(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym7.2.clone(); let ___nt = super::___action478::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (8, 150) } pub(crate) fn ___reduce458< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound = Path, "<", Comma, ">" => ActionFn(479); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant5(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action479::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (4, 150) } pub(crate) fn ___reduce459< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound = "for", "<", Comma, ">", Path => ActionFn(480); let ___sym4 = ___pop_Variant80(___symbols); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant57(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action480::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (5, 150) } pub(crate) fn ___reduce460< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound = Path => ActionFn(481); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action481::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant32(___nt), ___end)); (1, 150) } pub(crate) fn ___reduce461< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound? = TypeBound => ActionFn(209); let ___sym0 = ___pop_Variant32(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action209::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant91(___nt), ___end)); (1, 151) } pub(crate) fn ___reduce462< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBound? = => ActionFn(210); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action210::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant91(___nt), ___end)); (0, 151) } pub(crate) fn ___reduce463< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBoundParameter = Lifetime => ActionFn(19); let ___sym0 = ___pop_Variant22(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action19::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant34(___nt), ___end)); (1, 152) } pub(crate) fn ___reduce464< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBoundParameter = TypeRef => ActionFn(20); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action20::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant34(___nt), ___end)); (1, 152) } pub(crate) fn ___reduce465< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBoundParameter = Id, "=", TypeRef => ActionFn(21); let ___sym2 = ___pop_Variant3(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action21::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant34(___nt), ___end)); (3, 152) } pub(crate) fn ___reduce466< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBoundParameter? = TypeBoundParameter => ActionFn(219); let ___sym0 = ___pop_Variant34(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action219::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant92(___nt), ___end)); (1, 153) } pub(crate) fn ___reduce467< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBoundParameter? = => ActionFn(220); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action220::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant92(___nt), ___end)); (0, 153) } pub(crate) fn ___reduce468< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeBounds = Plus => ActionFn(15); let ___sym0 = ___pop_Variant84(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action15::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant84(___nt), ___end)); (1, 154) } pub(crate) fn ___reduce469< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeParameter = Lifetime => ActionFn(8); let ___sym0 = ___pop_Variant22(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action8::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant36(___nt), ___end)); (1, 155) } pub(crate) fn ___reduce470< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeParameter = Id => ActionFn(9); let ___sym0 = ___pop_Variant20(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action9::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant36(___nt), ___end)); (1, 155) } pub(crate) fn ___reduce471< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeParameter? = TypeParameter => ActionFn(196); let ___sym0 = ___pop_Variant36(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action196::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant93(___nt), ___end)); (1, 156) } pub(crate) fn ___reduce472< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeParameter? = => ActionFn(197); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action197::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant93(___nt), ___end)); (0, 156) } pub(crate) fn ___reduce473< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "(", Comma, ")" => ActionFn(69); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant58(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action69::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (3, 157) } pub(crate) fn ___reduce474< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "#", Symbol, "#" => ActionFn(70); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant30(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action70::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (3, 157) } pub(crate) fn ___reduce475< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "&", Lifetime, "mut", TypeRef => ActionFn(558); let ___sym3 = ___pop_Variant3(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant22(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action558::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (4, 157) } pub(crate) fn ___reduce476< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "&", "mut", TypeRef => ActionFn(559); let ___sym2 = ___pop_Variant3(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action559::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (3, 157) } pub(crate) fn ___reduce477< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "&", Lifetime, TypeRef => ActionFn(560); let ___sym2 = ___pop_Variant3(___symbols); let ___sym1 = ___pop_Variant22(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym2.2.clone(); let ___nt = super::___action560::<>(text, ___sym0, ___sym1, ___sym2); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (3, 157) } pub(crate) fn ___reduce478< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "&", TypeRef => ActionFn(561); let ___sym1 = ___pop_Variant3(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action561::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (2, 157) } pub(crate) fn ___reduce479< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = Path, "<", Comma, ">" => ActionFn(72); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant58(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action72::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (4, 157) } pub(crate) fn ___reduce480< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = Path => ActionFn(73); let ___sym0 = ___pop_Variant80(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action73::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (1, 157) } pub(crate) fn ___reduce481< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "dyn", Path, "<", Comma, ">" => ActionFn(74); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant58(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant80(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action74::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (5, 157) } pub(crate) fn ___reduce482< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "dyn", Path => ActionFn(75); let ___sym1 = ___pop_Variant80(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action75::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (2, 157) } pub(crate) fn ___reduce483< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "dyn", "for", "<", Comma, ">", Path, "(", Comma, ")", "->", TypeRef => ActionFn(482); let ___sym10 = ___pop_Variant3(___symbols); let ___sym9 = ___pop_Variant0(___symbols); let ___sym8 = ___pop_Variant0(___symbols); let ___sym7 = ___pop_Variant58(___symbols); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant80(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym10.2.clone(); let ___nt = super::___action482::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7, ___sym8, ___sym9, ___sym10); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (11, 157) } pub(crate) fn ___reduce484< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "dyn", Path, "(", Comma, ")", "->", TypeRef => ActionFn(483); let ___sym6 = ___pop_Variant3(___symbols); let ___sym5 = ___pop_Variant0(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant58(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant80(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym6.2.clone(); let ___nt = super::___action483::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (7, 157) } pub(crate) fn ___reduce485< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "dyn", "for", "<", Comma, ">", Path, "(", Comma, ")" => ActionFn(484); let ___sym8 = ___pop_Variant0(___symbols); let ___sym7 = ___pop_Variant58(___symbols); let ___sym6 = ___pop_Variant0(___symbols); let ___sym5 = ___pop_Variant80(___symbols); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant57(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym8.2.clone(); let ___nt = super::___action484::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4, ___sym5, ___sym6, ___sym7, ___sym8); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (9, 157) } pub(crate) fn ___reduce486< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef = "dyn", Path, "(", Comma, ")" => ActionFn(485); let ___sym4 = ___pop_Variant0(___symbols); let ___sym3 = ___pop_Variant58(___symbols); let ___sym2 = ___pop_Variant0(___symbols); let ___sym1 = ___pop_Variant80(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym4.2.clone(); let ___nt = super::___action485::<>(text, ___sym0, ___sym1, ___sym2, ___sym3, ___sym4); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (5, 157) } pub(crate) fn ___reduce487< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef? = TypeRef => ActionFn(214); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action214::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant4(___nt), ___end)); (1, 158) } pub(crate) fn ___reduce488< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRef? = => ActionFn(215); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action215::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant4(___nt), ___end)); (0, 158) } pub(crate) fn ___reduce489< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRefOrLifetime = TypeRef => ActionFn(77); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action77::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (1, 159) } pub(crate) fn ___reduce490< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRefOrLifetime = Lifetime => ActionFn(78); let ___sym0 = ___pop_Variant22(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action78::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant3(___nt), ___end)); (1, 159) } pub(crate) fn ___reduce491< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRefOrLifetime? = TypeRefOrLifetime => ActionFn(244); let ___sym0 = ___pop_Variant3(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action244::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant4(___nt), ___end)); (1, 160) } pub(crate) fn ___reduce492< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // TypeRefOrLifetime? = => ActionFn(245); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action245::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant4(___nt), ___end)); (0, 160) } pub(crate) fn ___reduce493< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Use = "use", ";" => ActionFn(28); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant1(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action28::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant63(___nt), ___end)); (2, 161) } pub(crate) fn ___reduce494< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Use* = => ActionFn(184); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action184::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant66(___nt), ___end)); (0, 162) } pub(crate) fn ___reduce495< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Use* = Use+ => ActionFn(185); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action185::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant66(___nt), ___end)); (1, 162) } pub(crate) fn ___reduce496< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Use+ = Use => ActionFn(190); let ___sym0 = ___pop_Variant63(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action190::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant66(___nt), ___end)); (1, 163) } pub(crate) fn ___reduce497< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Use+ = Use+, Use => ActionFn(191); let ___sym1 = ___pop_Variant63(___symbols); let ___sym0 = ___pop_Variant66(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym1.2.clone(); let ___nt = super::___action191::<>(text, ___sym0, ___sym1); ___symbols.push((___start, ___Symbol::Variant66(___nt), ___end)); (2, 163) } pub(crate) fn ___reduce498< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Visibility = "pub", "(", Path, ")" => ActionFn(29); let ___sym3 = ___pop_Variant0(___symbols); let ___sym2 = ___pop_Variant80(___symbols); let ___sym1 = ___pop_Variant0(___symbols); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym3.2.clone(); let ___nt = super::___action29::<>(text, ___sym0, ___sym1, ___sym2, ___sym3); ___symbols.push((___start, ___Symbol::Variant94(___nt), ___end)); (4, 164) } pub(crate) fn ___reduce499< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Visibility = "pub" => ActionFn(30); let ___sym0 = ___pop_Variant0(___symbols); let ___start = ___sym0.0.clone(); let ___end = ___sym0.2.clone(); let ___nt = super::___action30::<>(text, ___sym0); ___symbols.push((___start, ___Symbol::Variant94(___nt), ___end)); (1, 164) } pub(crate) fn ___reduce500< 'input, >( text: &'input str, ___action: i16, ___lookahead_start: Option<&usize>, ___states: &mut ::std::vec::Vec, ___symbols: &mut ::std::vec::Vec<(usize,___Symbol<'input>,usize)>, _: ::std::marker::PhantomData<(&'input ())>, ) -> (usize, usize) { // Visibility = => ActionFn(323); let ___start = ___symbols.last().map(|s| s.2.clone()).unwrap_or_default(); let ___end = ___lookahead_start.cloned().unwrap_or_else(|| ___start.clone()); let ___nt = super::___action323::<>(text, &___start, &___end); ___symbols.push((___start, ___Symbol::Variant94(___nt), ___end)); (0, 164) } } pub use self::___parse___Top::TopParser; #[allow(unused_variables)] fn ___action0< 'input, >( text: &'input str, (_, ___0, _): (usize, Top, usize), ) -> Top { (___0) } #[allow(unused_variables)] fn ___action1< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Grammar, usize), ) -> Top { Top::Grammar(___0) } #[allow(unused_variables)] fn ___action2< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Pattern, usize), ) -> Top { Top::Pattern(___0) } #[allow(unused_variables)] fn ___action3< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, TerminalString, usize), ) -> Top { Top::MatchMapping(___0) } #[allow(unused_variables)] fn ___action4< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, TypeRef, usize), ) -> Top { Top::TypeRef(___0) } #[allow(unused_variables)] fn ___action5< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Vec>, usize), ) -> Top { Top::GrammarWhereClauses(___0) } #[allow(unused_variables)] fn ___action6< 'input, >( text: &'input str, (_, module_attributes, _): (usize, ::std::vec::Vec, usize), (_, uses, _): (usize, ::std::vec::Vec, usize), (_, annotations, _): (usize, ::std::vec::Vec, usize), (_, lo, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, hi, _): (usize, usize, usize), (_, tps, _): (usize, ::std::option::Option>, usize), (_, parameters, _): (usize, ::std::option::Option>, usize), (_, where_clauses, _): (usize, ::std::option::Option>>, usize), (_, _, _): (usize, Tok<'input>, usize), (_, items, _): (usize, ::std::vec::Vec, usize), ) -> Grammar { { Grammar { prefix: format!("__"), // adjusted by `parse_grammar` span: Span(lo, hi), type_parameters: tps.unwrap_or(vec![]), parameters: parameters.unwrap_or(vec![]), where_clauses: where_clauses.unwrap_or(vec![]), items: uses.into_iter().chain(items).collect(), annotations, module_attributes } } } #[allow(unused_variables)] fn ___action7< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Vec { (___0) } #[allow(unused_variables)] fn ___action8< 'input, >( text: &'input str, (_, l, _): (usize, Lifetime, usize), ) -> TypeParameter { TypeParameter::Lifetime(l) } #[allow(unused_variables)] fn ___action9< 'input, >( text: &'input str, (_, l, _): (usize, Atom, usize), ) -> TypeParameter { TypeParameter::Id(l) } #[allow(unused_variables)] fn ___action10< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Vec>, usize), ) -> Vec> { (___0) } #[allow(unused_variables)] fn ___action11< 'input, >( text: &'input str, (_, l, _): (usize, Lifetime, usize), (_, _, _): (usize, Tok<'input>, usize), (_, bounds, _): (usize, Vec, usize), ) -> WhereClause { WhereClause::Lifetime { lifetime: l, bounds } } #[allow(unused_variables)] fn ___action12< 'input, >( text: &'input str, (_, f, _): (usize, Vec, usize), (_, ty, _): (usize, TypeRef, usize), (_, _, _): (usize, Tok<'input>, usize), (_, bounds, _): (usize, Vec>, usize), ) -> WhereClause { WhereClause::Type { forall: f, ty, bounds } } #[allow(unused_variables)] fn ___action13< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Vec { (___0) } #[allow(unused_variables)] fn ___action14< 'input, >( text: &'input str, (_, ___0, _): (usize, (), usize), ) -> Vec { vec![] } #[allow(unused_variables)] fn ___action15< 'input, >( text: &'input str, (_, ___0, _): (usize, Vec>, usize), ) -> Vec> { (___0) } #[allow(unused_variables)] fn ___action16< 'input, >( text: &'input str, (_, l, _): (usize, Lifetime, usize), ) -> TypeBound { TypeBound::Lifetime(l) } #[allow(unused_variables)] fn ___action17< 'input, >( text: &'input str, (_, f, _): (usize, Vec, usize), (_, p, _): (usize, Path, usize), (_, _, _): (usize, Tok<'input>, usize), (_, params, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), (_, ret, _): (usize, ::std::option::Option, usize), ) -> TypeBound { TypeBound::Fn { forall: f, path: p, parameters: params, ret } } #[allow(unused_variables)] fn ___action18< 'input, >( text: &'input str, (_, f, _): (usize, Vec, usize), (_, p, _): (usize, Path, usize), (_, params, _): (usize, ::std::option::Option>>, usize), ) -> TypeBound { TypeBound::Trait { forall: f, path: p, parameters: params.unwrap_or(vec![]) } } #[allow(unused_variables)] fn ___action19< 'input, >( text: &'input str, (_, l, _): (usize, Lifetime, usize), ) -> TypeBoundParameter { TypeBoundParameter::Lifetime(l) } #[allow(unused_variables)] fn ___action20< 'input, >( text: &'input str, (_, ty, _): (usize, TypeRef, usize), ) -> TypeBoundParameter { TypeBoundParameter::TypeParameter(ty) } #[allow(unused_variables)] fn ___action21< 'input, >( text: &'input str, (_, id, _): (usize, Atom, usize), (_, _, _): (usize, Tok<'input>, usize), (_, ty, _): (usize, TypeRef, usize), ) -> TypeBoundParameter { TypeBoundParameter::Associated(id, ty) } #[allow(unused_variables)] fn ___action22< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Vec { (___0) } #[allow(unused_variables)] fn ___action23< 'input, >( text: &'input str, (_, id, _): (usize, Atom, usize), (_, _, _): (usize, Tok<'input>, usize), (_, ty, _): (usize, TypeRef, usize), ) -> Parameter { Parameter { name: id, ty } } #[allow(unused_variables)] fn ___action24< 'input, >( text: &'input str, (_, ___0, _): (usize, GrammarItem, usize), ) -> GrammarItem { (___0) } #[allow(unused_variables)] fn ___action25< 'input, >( text: &'input str, (_, ___0, _): (usize, GrammarItem, usize), ) -> GrammarItem { (___0) } #[allow(unused_variables)] fn ___action26< 'input, >( text: &'input str, (_, ___0, _): (usize, GrammarItem, usize), ) -> GrammarItem { (___0) } #[allow(unused_variables)] fn ___action27< 'input, >( text: &'input str, (_, ___0, _): (usize, GrammarItem, usize), ) -> GrammarItem { (___0) } #[allow(unused_variables)] fn ___action28< 'input, >( text: &'input str, (_, u, _): (usize, &'input str, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> GrammarItem { GrammarItem::Use(strip(u).to_string()) } #[allow(unused_variables)] fn ___action29< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, _, _): (usize, Tok<'input>, usize), (_, p, _): (usize, Path, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Visibility { Visibility::Pub(Some(p)) } #[allow(unused_variables)] fn ___action30< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> Visibility { Visibility::Pub(None) } #[allow(unused_variables)] fn ___action31< 'input, >( text: &'input str, (_, ___0, _): (usize, (), usize), ) -> Visibility { Visibility::Priv } #[allow(unused_variables)] fn ___action32< 'input, >( text: &'input str, (_, annotations, _): (usize, ::std::vec::Vec, usize), (_, v, _): (usize, Visibility, usize), (_, lo, _): (usize, usize, usize), (_, n, _): (usize, (NonterminalString, Vec), usize), (_, hi, _): (usize, usize, usize), (_, t, _): (usize, ::std::option::Option, usize), (_, _, _): (usize, Tok<'input>, usize), (_, a, _): (usize, Vec, usize), ) -> GrammarItem { { GrammarItem::Nonterminal(NonterminalData { visibility: v, span: Span(lo, hi), name: n.0, annotations, args: n.1, type_decl: t, alternatives: a }) } } #[allow(unused_variables)] fn ___action33< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, name, _): (usize, Atom, usize), (_, _, _): (usize, Tok<'input>, usize), (_, value, _): (usize, &'input str, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> (Atom, String) { (name, value.into()) } #[allow(unused_variables)] fn ___action34< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, _, _): (usize, Tok<'input>, usize), (_, lo, _): (usize, usize, usize), (_, id, _): (usize, Atom, usize), (_, arg, _): (usize, ::std::option::Option<(Atom, String)>, usize), (_, hi, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Annotation { { Annotation { id_span: Span(lo, hi), id, arg } } } #[allow(unused_variables)] fn ___action35< 'input, >( text: &'input str, (_, ___0, _): (usize, NonterminalString, usize), (_, _, _): (usize, Tok<'input>, usize), (_, ___1, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> (NonterminalString, Vec) { (___0, ___1) } #[allow(unused_variables)] fn ___action36< 'input, >( text: &'input str, (_, n, _): (usize, NonterminalString, usize), ) -> (NonterminalString, Vec) { (n, vec![]) } #[allow(unused_variables)] fn ___action37< 'input, >( text: &'input str, (_, ___0, _): (usize, &'input str, usize), ) -> (NonterminalString, Vec) { (NonterminalString(Atom::from(___0)), vec![]) } #[allow(unused_variables)] fn ___action38< 'input, >( text: &'input str, (_, a, _): (usize, Alternative, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Vec { vec![a] } #[allow(unused_variables)] fn ___action39< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), (_, _, _): (usize, ::std::option::Option>, usize), ) -> Vec { (___0) } #[allow(unused_variables)] fn ___action40< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, s, _): (usize, ::std::vec::Vec, usize), (_, c, _): (usize, ::std::option::Option, usize), (_, a, _): (usize, ::std::option::Option, usize), (_, hi, _): (usize, usize, usize), ) -> Alternative { { Alternative { span: Span(lo, hi), expr: ExprSymbol { symbols: s }, condition: c, action: a } } } #[allow(unused_variables)] fn ___action41< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, c, _): (usize, ::std::option::Option, usize), (_, a, _): (usize, ActionKind, usize), (_, hi, _): (usize, usize, usize), ) -> Alternative { { Alternative { span: Span(lo, hi), expr: ExprSymbol { symbols: vec![] }, condition: c, action: Some(a) } } } #[allow(unused_variables)] fn ___action42< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> ActionKind { ActionKind::Lookahead } #[allow(unused_variables)] fn ___action43< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> ActionKind { ActionKind::Lookbehind } #[allow(unused_variables)] fn ___action44< 'input, >( text: &'input str, (_, c, _): (usize, &'input str, usize), ) -> ActionKind { ActionKind::User(strip(c).to_string()) } #[allow(unused_variables)] fn ___action45< 'input, >( text: &'input str, (_, c, _): (usize, &'input str, usize), ) -> ActionKind { ActionKind::Fallible(strip(c).to_string()) } #[allow(unused_variables)] fn ___action46< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, a, _): (usize, NonterminalString, usize), (_, op, _): (usize, ConditionOp, usize), (_, b, _): (usize, Atom, usize), (_, hi, _): (usize, usize, usize), ) -> Condition { { Condition { span:Span(lo, hi), lhs:a, rhs:b, op } } } #[allow(unused_variables)] fn ___action47< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> ConditionOp { ConditionOp::Equals } #[allow(unused_variables)] fn ___action48< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> ConditionOp { ConditionOp::NotEquals } #[allow(unused_variables)] fn ___action49< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> ConditionOp { ConditionOp::Match } #[allow(unused_variables)] fn ___action50< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> ConditionOp { ConditionOp::NotMatch } #[allow(unused_variables)] fn ___action51< 'input, >( text: &'input str, (_, ___0, _): (usize, ::std::vec::Vec, usize), ) -> ExprSymbol { ExprSymbol { symbols: ___0 } } #[allow(unused_variables)] fn ___action52< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, m, _): (usize, ::std::option::Option>, usize), (_, _, _): (usize, usize, usize), (_, l, _): (usize, Atom, usize), (_, _, _): (usize, Tok<'input>, usize), (_, s, _): (usize, Symbol, usize), (_, _, _): (usize, Tok<'input>, usize), (_, hi, _): (usize, usize, usize), ) -> Symbol { Symbol::new(Span(lo, hi), SymbolKind::Name(Name::new(m.is_some(), l), Box::new(s))) } #[allow(unused_variables)] fn ___action53< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, s, _): (usize, Symbol, usize), (_, _, _): (usize, Tok<'input>, usize), (_, hi, _): (usize, usize, usize), ) -> Symbol { Symbol::new(Span(lo, hi), SymbolKind::Choose(Box::new(s))) } #[allow(unused_variables)] fn ___action54< 'input, >( text: &'input str, (_, ___0, _): (usize, Symbol, usize), ) -> Symbol { (___0) } #[allow(unused_variables)] fn ___action55< 'input, >( text: &'input str, (_, ___0, _): (usize, Symbol, usize), ) -> Symbol { (___0) } #[allow(unused_variables)] fn ___action56< 'input, >( text: &'input str, (_, lhs, _): (usize, Symbol, usize), (_, op, _): (usize, RepeatOp, usize), (_, hi, _): (usize, usize, usize), ) -> Symbol { Symbol::new(Span(lhs.span.0, hi), SymbolKind::Repeat(Box::new(RepeatSymbol { symbol: lhs, op }))) } #[allow(unused_variables)] fn ___action57< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> RepeatOp { RepeatOp::Plus } #[allow(unused_variables)] fn ___action58< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> RepeatOp { RepeatOp::Star } #[allow(unused_variables)] fn ___action59< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> RepeatOp { RepeatOp::Question } #[allow(unused_variables)] fn ___action60< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, sk, _): (usize, SymbolKind, usize), (_, hi, _): (usize, usize, usize), ) -> Symbol { Symbol::new(Span(lo, hi), sk) } #[allow(unused_variables)] fn ___action61< 'input, >( text: &'input str, (_, name, _): (usize, NonterminalString, usize), (_, _, _): (usize, Tok<'input>, usize), (_, args, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> SymbolKind { SymbolKind::Macro(MacroSymbol { name, args }) } #[allow(unused_variables)] fn ___action62< 'input, >( text: &'input str, (_, ___0, _): (usize, TerminalString, usize), ) -> SymbolKind { SymbolKind::Terminal(___0) } #[allow(unused_variables)] fn ___action63< 'input, >( text: &'input str, (_, ___0, _): (usize, &'input str, usize), ) -> SymbolKind { SymbolKind::AmbiguousId(Atom::from(___0)) } #[allow(unused_variables)] fn ___action64< 'input, >( text: &'input str, (_, ___0, _): (usize, Atom, usize), ) -> SymbolKind { SymbolKind::Nonterminal(NonterminalString(___0)) } #[allow(unused_variables)] fn ___action65< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, ExprSymbol, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> SymbolKind { SymbolKind::Expr(___0) } #[allow(unused_variables)] fn ___action66< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> SymbolKind { SymbolKind::Lookahead } #[allow(unused_variables)] fn ___action67< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> SymbolKind { SymbolKind::Lookbehind } #[allow(unused_variables)] fn ___action68< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> SymbolKind { SymbolKind::Error } #[allow(unused_variables)] fn ___action69< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> TypeRef { TypeRef::Tuple(___0) } #[allow(unused_variables)] fn ___action70< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Symbol, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> TypeRef { { TypeRef::OfSymbol(___0.kind) } } #[allow(unused_variables)] fn ___action71< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, l, _): (usize, ::std::option::Option, usize), (_, m, _): (usize, ::std::option::Option>, usize), (_, t, _): (usize, TypeRef, usize), ) -> TypeRef { TypeRef::Ref { lifetime: l, mutable: m.is_some(), referent: Box::new(t) } } #[allow(unused_variables)] fn ___action72< 'input, >( text: &'input str, (_, path, _): (usize, Path, usize), (_, _, _): (usize, Tok<'input>, usize), (_, types, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> TypeRef { TypeRef::Nominal { path:path, types:types } } #[allow(unused_variables)] fn ___action73< 'input, >( text: &'input str, (_, p, _): (usize, Path, usize), ) -> TypeRef { match p.as_id() { Some(id) => TypeRef::Id(id), None => TypeRef::Nominal { path: p, types: vec![] }, } } #[allow(unused_variables)] fn ___action74< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, path, _): (usize, Path, usize), (_, _, _): (usize, Tok<'input>, usize), (_, types, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> TypeRef { TypeRef::TraitObject { path:path, types:types } } #[allow(unused_variables)] fn ___action75< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, path, _): (usize, Path, usize), ) -> TypeRef { TypeRef::TraitObject { path, types: vec![] } } #[allow(unused_variables)] fn ___action76< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, forall, _): (usize, Vec, usize), (_, path, _): (usize, Path, usize), (_, _, _): (usize, Tok<'input>, usize), (_, parameters, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), (_, ret, _): (usize, ::std::option::Option, usize), ) -> TypeRef { TypeRef::Fn { forall, path, parameters, ret: ret.map(Box::new) } } #[allow(unused_variables)] fn ___action77< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeRef, usize), ) -> TypeRef { (___0) } #[allow(unused_variables)] fn ___action78< 'input, >( text: &'input str, (_, ___0, _): (usize, Lifetime, usize), ) -> TypeRef { TypeRef::Lifetime(___0) } #[allow(unused_variables)] fn ___action79< 'input, >( text: &'input str, (_, a, _): (usize, ::std::option::Option>, usize), (_, h, _): (usize, ::std::vec::Vec, usize), (_, t, _): (usize, Atom, usize), ) -> Path { { Path { absolute: a.is_some(), ids: h.into_iter().chain(once(t)).collect() } } } #[allow(unused_variables)] fn ___action80< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, hi, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, a0, _): (usize, ::std::vec::Vec, usize), (_, et, _): (usize, EnumToken, usize), (_, a1, _): (usize, ::std::vec::Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> GrammarItem { { GrammarItem::ExternToken(ExternToken { span: Span(lo, hi), associated_types: a0.into_iter().chain(a1).collect(), enum_token: Some(et), }) } } #[allow(unused_variables)] fn ___action81< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, hi, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, a0, _): (usize, ::std::vec::Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> GrammarItem { { GrammarItem::ExternToken(ExternToken { span: Span(lo, hi), associated_types: a0, enum_token: None, }) } } #[allow(unused_variables)] fn ___action82< 'input, >( text: &'input str, (_, t, _): (usize, MatchToken, usize), ) -> GrammarItem { GrammarItem::MatchToken(t) } #[allow(unused_variables)] fn ___action83< 'input, >( text: &'input str, (_, t, _): (usize, MatchToken, usize), (_, _, _): (usize, Tok<'input>, usize), (_, _, _): (usize, Tok<'input>, usize), (_, c, _): (usize, MatchContents, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> MatchToken { t.add(c) } #[allow(unused_variables)] fn ___action84< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, hi, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, c, _): (usize, MatchContents, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> MatchToken { MatchToken::new(c, Span(lo, hi)) } #[allow(unused_variables)] fn ___action85< 'input, >( text: &'input str, (_, items, _): (usize, Vec, usize), ) -> MatchContents { MatchContents { items } } #[allow(unused_variables)] fn ___action86< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, hi, _): (usize, usize, usize), ) -> MatchItem { MatchItem::CatchAll(Span(lo, hi)) } #[allow(unused_variables)] fn ___action87< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, s, _): (usize, TerminalLiteral, usize), (_, hi, _): (usize, usize, usize), ) -> MatchItem { MatchItem::Unmapped(s, Span(lo, hi)) } #[allow(unused_variables)] fn ___action88< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, from, _): (usize, TerminalLiteral, usize), (_, start, _): (usize, usize, usize), (_, p, _): (usize, &'input str, usize), (_, hi, _): (usize, usize, usize), ) -> Result,tok::Error>> { { let to = super::parse_match_mapping(p, start + 2)?; Ok(MatchItem::Mapped(from, to, Span(lo, hi))) } } #[allow(unused_variables)] fn ___action89< 'input, >( text: &'input str, (_, ___0, _): (usize, TerminalLiteral, usize), ) -> TerminalLiteral { (___0) } #[allow(unused_variables)] fn ___action90< 'input, >( text: &'input str, (_, ___0, _): (usize, TerminalString, usize), ) -> TerminalString { (___0) } #[allow(unused_variables)] fn ___action91< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, lo, _): (usize, usize, usize), (_, t, _): (usize, TypeRef, usize), (_, hi, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, c, _): (usize, Vec, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> EnumToken { { EnumToken { type_name: t, type_span: Span(lo, hi), conversions: c, } } } #[allow(unused_variables)] fn ___action92< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, lo, _): (usize, usize, usize), (_, n, _): (usize, Atom, usize), (_, hi, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, t, _): (usize, TypeRef, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> AssociatedType { { AssociatedType { type_span: Span(lo, hi), type_name: n, type_ref: t } } } #[allow(unused_variables)] fn ___action93< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, from, _): (usize, TerminalString, usize), (_, start, _): (usize, usize, usize), (_, p, _): (usize, &'input str, usize), (_, hi, _): (usize, usize, usize), ) -> Result,tok::Error>> { { let pattern = super::parse_pattern(p, start + 2)?; Ok(Conversion { span: Span(lo, hi), from, to: pattern }) } } #[allow(unused_variables)] fn ___action94< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, k, _): (usize, PatternKind, usize), (_, hi, _): (usize, usize, usize), ) -> Pattern { Pattern { span: Span(lo, hi), kind: k } } #[allow(unused_variables)] fn ___action95< 'input, >( text: &'input str, (_, ___0, _): (usize, Path, usize), (_, _, _): (usize, Tok<'input>, usize), (_, ___1, _): (usize, Vec>, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> PatternKind { PatternKind::Enum(___0, ___1) } #[allow(unused_variables)] fn ___action96< 'input, >( text: &'input str, (_, p, _): (usize, Path, usize), (_, _, _): (usize, Tok<'input>, usize), (_, a0, _): (usize, ::std::vec::Vec>, usize), (_, a1, _): (usize, ::std::option::Option>, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> PatternKind { PatternKind::Struct(p, a0.into_iter().chain(a1).collect(), false) } #[allow(unused_variables)] fn ___action97< 'input, >( text: &'input str, (_, p, _): (usize, Path, usize), (_, _, _): (usize, Tok<'input>, usize), (_, a0, _): (usize, ::std::vec::Vec>, usize), (_, _, _): (usize, Tok<'input>, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> PatternKind { PatternKind::Struct(p, a0, true) } #[allow(unused_variables)] fn ___action98< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> PatternKind { PatternKind::Underscore } #[allow(unused_variables)] fn ___action99< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> PatternKind { PatternKind::DotDot } #[allow(unused_variables)] fn ___action100< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, TypeRef, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> PatternKind { PatternKind::Choose(___0) } #[allow(unused_variables)] fn ___action101< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Vec>, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> PatternKind { PatternKind::Tuple(___0) } #[allow(unused_variables)] fn ___action102< 'input, >( text: &'input str, (_, c, _): (usize, &'input str, usize), ) -> PatternKind { PatternKind::CharLiteral(Atom::from(c)) } #[allow(unused_variables)] fn ___action103< 'input, >( text: &'input str, (_, ___0, _): (usize, Path, usize), ) -> PatternKind { PatternKind::Path(___0) } #[allow(unused_variables)] fn ___action104< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, id, _): (usize, Atom, usize), (_, hi, _): (usize, usize, usize), (_, _, _): (usize, Tok<'input>, usize), (_, pat, _): (usize, Pattern, usize), ) -> FieldPattern { { FieldPattern { field_span: Span(lo, hi), field_name: id, pattern: pat } } } #[allow(unused_variables)] fn ___action105< 'input, >( text: &'input str, (_, i, _): (usize, &'input str, usize), ) -> NonterminalString { NonterminalString(Atom::from(i)) } #[allow(unused_variables)] fn ___action106< 'input, >( text: &'input str, (_, i, _): (usize, &'input str, usize), ) -> NonterminalString { NonterminalString(Atom::from(i)) } #[allow(unused_variables)] fn ___action107< 'input, >( text: &'input str, (_, i, _): (usize, &'input str, usize), ) -> Atom { Atom::from(i) } #[allow(unused_variables)] fn ___action108< 'input, >( text: &'input str, (_, i, _): (usize, &'input str, usize), ) -> Atom { Atom::from(i) } #[allow(unused_variables)] fn ___action109< 'input, >( text: &'input str, (_, i, _): (usize, &'input str, usize), ) -> Atom { Atom::from(i) } #[allow(unused_variables)] fn ___action110< 'input, >( text: &'input str, (_, i, _): (usize, &'input str, usize), ) -> Lifetime { Lifetime(Atom::from(i)) } #[allow(unused_variables)] fn ___action111< 'input, >( text: &'input str, (_, ___0, _): (usize, TerminalString, usize), ) -> TerminalString { (___0) } #[allow(unused_variables)] fn ___action112< 'input, >( text: &'input str, (_, i, _): (usize, &'input str, usize), ) -> TerminalString { TerminalString::Bare(Atom::from(i)) } #[allow(unused_variables)] fn ___action113< 'input, >( text: &'input str, (_, ___0, _): (usize, TerminalLiteral, usize), ) -> TerminalString { TerminalString::Literal(___0) } #[allow(unused_variables)] fn ___action114< 'input, >( text: &'input str, (_, s, _): (usize, Atom, usize), ) -> TerminalLiteral { TerminalLiteral::Quoted(s) } #[allow(unused_variables)] fn ___action115< 'input, >( text: &'input str, (_, s, _): (usize, Atom, usize), ) -> TerminalLiteral { TerminalLiteral::Regex(s) } #[allow(unused_variables)] fn ___action116< 'input, >( text: &'input str, (_, lo, _): (usize, usize, usize), (_, s, _): (usize, &'input str, usize), ) -> Result,tok::Error>> { { let text = tok::apply_string_escapes(s, lo + 1) .map_err(|e| ParseError::User { error: e })?; Ok(Atom::from(text)) } } #[allow(unused_variables)] fn ___action117< 'input, >( text: &'input str, (_, s, _): (usize, &'input str, usize), ) -> Atom { Atom::from(s) } #[allow(unused_variables)] fn ___action118< 'input, >( text: &'input str, (_, s, _): (usize, &'input str, usize), ) -> String { s.to_string() } #[allow(unused_variables)] fn ___action119< 'input, >( text: &'input str, (_, ___0, _): (usize, FieldPattern, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action120< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action121< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec> { vec![] } #[allow(unused_variables)] fn ___action122< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), ) -> ::std::vec::Vec> { v } #[allow(unused_variables)] fn ___action123< 'input, >( text: &'input str, (_, ___0, _): (usize, FieldPattern, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> FieldPattern { (___0) } #[allow(unused_variables)] fn ___action124< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec>, usize), (_, e1, _): (usize, ::std::option::Option>, usize), ) -> Vec> { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action125< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec, usize), (_, e1, _): (usize, ::std::option::Option, usize), ) -> Vec { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action126< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec, usize), (_, e1, _): (usize, ::std::option::Option, usize), ) -> Vec { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action127< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action128< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action129< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action130< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action131< 'input, >( text: &'input str, (_, ___0, _): (usize, Atom, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Atom { (___0) } #[allow(unused_variables)] fn ___action132< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action133< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action134< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec, usize), (_, e1, _): (usize, ::std::option::Option, usize), ) -> Vec { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action135< 'input, >( text: &'input str, (_, ___0, _): (usize, Lifetime, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action136< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action137< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec, usize), (_, e1, _): (usize, ::std::option::Option, usize), ) -> Vec { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action138< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action139< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action140< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action141< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action142< 'input, >( text: &'input str, (_, ___0, _): (usize, ActionKind, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action143< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action144< 'input, >( text: &'input str, (_, ___0, _): (usize, Condition, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action145< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action146< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Condition, usize), ) -> Condition { (___0) } #[allow(unused_variables)] fn ___action147< 'input, >( text: &'input str, (_, ___0, _): (usize, Symbol, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action148< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, Symbol, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action149< 'input, >( text: &'input str, (_, ___0, _): (usize, Tok<'input>, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action150< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action151< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec, usize), (_, e1, _): (usize, ::std::option::Option, usize), ) -> Vec { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action152< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec, usize), (_, e1, _): (usize, ::std::option::Option, usize), ) -> Vec { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action153< 'input, >( text: &'input str, (_, ___0, _): (usize, (Atom, String), usize), ) -> ::std::option::Option<(Atom, String)> { Some(___0) } #[allow(unused_variables)] fn ___action154< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option<(Atom, String)> { None } #[allow(unused_variables)] fn ___action155< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeRef, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action156< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action157< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, TypeRef, usize), ) -> TypeRef { (___0) } #[allow(unused_variables)] fn ___action158< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec, usize), (_, e1, _): (usize, ::std::option::Option, usize), ) -> Vec { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action159< 'input, >( text: &'input str, (_, ___0, _): (usize, Vec>, usize), ) -> ::std::option::Option>> { Some(___0) } #[allow(unused_variables)] fn ___action160< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option>> { None } #[allow(unused_variables)] fn ___action161< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, Vec>, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Vec> { (___0) } #[allow(unused_variables)] fn ___action162< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec>, usize), (_, e1, _): (usize, ::std::option::Option>, usize), ) -> Vec> { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action163< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeRef, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action164< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action165< 'input, >( text: &'input str, (_, _, _): (usize, Tok<'input>, usize), (_, ___0, _): (usize, TypeRef, usize), ) -> TypeRef { (___0) } #[allow(unused_variables)] fn ___action166< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec, usize), (_, e1, _): (usize, ::std::option::Option, usize), ) -> Vec { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action167< 'input, >( text: &'input str, (_, mut v, _): (usize, ::std::vec::Vec>, usize), (_, e, _): (usize, ::std::option::Option>, usize), ) -> Vec> { match e { None => v, Some(e) => { v.push(e); v } } } #[allow(unused_variables)] fn ___action168< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> () { () } #[allow(unused_variables)] fn ___action169< 'input, >( text: &'input str, (_, mut v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, ::std::option::Option, usize), ) -> Vec { match e { None => v, Some(e) => { v.push(e); v } } } #[allow(unused_variables)] fn ___action170< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec>, usize), (_, e1, _): (usize, ::std::option::Option>, usize), ) -> Vec> { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action171< 'input, >( text: &'input str, (_, v0, _): (usize, ::std::vec::Vec, usize), (_, e1, _): (usize, ::std::option::Option, usize), ) -> Vec { v0.into_iter().chain(e1).collect() } #[allow(unused_variables)] fn ___action172< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action173< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action174< 'input, >( text: &'input str, (_, ___0, _): (usize, Vec>, usize), ) -> ::std::option::Option>> { Some(___0) } #[allow(unused_variables)] fn ___action175< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option>> { None } #[allow(unused_variables)] fn ___action176< 'input, >( text: &'input str, (_, ___0, _): (usize, Vec, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action177< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action178< 'input, >( text: &'input str, (_, ___0, _): (usize, Vec, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action179< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action180< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> usize { ___lookbehind.clone() } #[allow(unused_variables)] fn ___action181< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> usize { ___lookahead.clone() } #[allow(unused_variables)] fn ___action182< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action183< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action184< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action185< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action186< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action187< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action188< 'input, >( text: &'input str, (_, ___0, _): (usize, String, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action189< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, String, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action190< 'input, >( text: &'input str, (_, ___0, _): (usize, GrammarItem, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action191< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, GrammarItem, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action192< 'input, >( text: &'input str, (_, ___0, _): (usize, Annotation, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action193< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, Annotation, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action194< 'input, >( text: &'input str, (_, ___0, _): (usize, GrammarItem, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action195< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, GrammarItem, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action196< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeParameter, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action197< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action198< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action199< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action200< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeParameter, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> TypeParameter { (___0) } #[allow(unused_variables)] fn ___action201< 'input, >( text: &'input str, (_, ___0, _): (usize, WhereClause, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action202< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action203< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec> { vec![] } #[allow(unused_variables)] fn ___action204< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), ) -> ::std::vec::Vec> { v } #[allow(unused_variables)] fn ___action205< 'input, >( text: &'input str, (_, ___0, _): (usize, WhereClause, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> WhereClause { (___0) } #[allow(unused_variables)] fn ___action206< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action207< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action208< 'input, >( text: &'input str, (_, ___0, _): (usize, Lifetime, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Lifetime { (___0) } #[allow(unused_variables)] fn ___action209< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeBound, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action210< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action211< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec> { vec![] } #[allow(unused_variables)] fn ___action212< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), ) -> ::std::vec::Vec> { v } #[allow(unused_variables)] fn ___action213< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeBound, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> TypeBound { (___0) } #[allow(unused_variables)] fn ___action214< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeRef, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action215< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action216< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action217< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action218< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeRef, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> TypeRef { (___0) } #[allow(unused_variables)] fn ___action219< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeBoundParameter, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action220< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action221< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec> { vec![] } #[allow(unused_variables)] fn ___action222< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), ) -> ::std::vec::Vec> { v } #[allow(unused_variables)] fn ___action223< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeBoundParameter, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> TypeBoundParameter { (___0) } #[allow(unused_variables)] fn ___action224< 'input, >( text: &'input str, (_, ___0, _): (usize, Parameter, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action225< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action226< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action227< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action228< 'input, >( text: &'input str, (_, ___0, _): (usize, Parameter, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Parameter { (___0) } #[allow(unused_variables)] fn ___action229< 'input, >( text: &'input str, (_, ___0, _): (usize, NonterminalString, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action230< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action231< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action232< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action233< 'input, >( text: &'input str, (_, ___0, _): (usize, NonterminalString, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> NonterminalString { (___0) } #[allow(unused_variables)] fn ___action234< 'input, >( text: &'input str, (_, ___0, _): (usize, Alternative, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action235< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action236< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action237< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action238< 'input, >( text: &'input str, (_, ___0, _): (usize, Alternative, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Alternative { (___0) } #[allow(unused_variables)] fn ___action239< 'input, >( text: &'input str, (_, ___0, _): (usize, Symbol, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action240< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action241< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action242< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action243< 'input, >( text: &'input str, (_, ___0, _): (usize, Symbol, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Symbol { (___0) } #[allow(unused_variables)] fn ___action244< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeRef, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action245< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action246< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action247< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action248< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeRef, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> TypeRef { (___0) } #[allow(unused_variables)] fn ___action249< 'input, >( text: &'input str, (_, ___0, _): (usize, Atom, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action250< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, Atom, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action251< 'input, >( text: &'input str, (_, ___0, _): (usize, AssociatedType, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action252< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, AssociatedType, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action253< 'input, >( text: &'input str, (_, ___0, _): (usize, MatchItem, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action254< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action255< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action256< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action257< 'input, >( text: &'input str, (_, ___0, _): (usize, MatchItem, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> MatchItem { (___0) } #[allow(unused_variables)] fn ___action258< 'input, >( text: &'input str, (_, ___0, _): (usize, Conversion, usize), ) -> ::std::option::Option { Some(___0) } #[allow(unused_variables)] fn ___action259< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option { None } #[allow(unused_variables)] fn ___action260< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec { vec![] } #[allow(unused_variables)] fn ___action261< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), ) -> ::std::vec::Vec { v } #[allow(unused_variables)] fn ___action262< 'input, >( text: &'input str, (_, ___0, _): (usize, Conversion, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Conversion { (___0) } #[allow(unused_variables)] fn ___action263< 'input, >( text: &'input str, (_, ___0, _): (usize, Pattern, usize), ) -> ::std::option::Option> { Some(___0) } #[allow(unused_variables)] fn ___action264< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::option::Option> { None } #[allow(unused_variables)] fn ___action265< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ::std::vec::Vec> { vec![] } #[allow(unused_variables)] fn ___action266< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), ) -> ::std::vec::Vec> { v } #[allow(unused_variables)] fn ___action267< 'input, >( text: &'input str, (_, ___0, _): (usize, Pattern, usize), (_, _, _): (usize, Tok<'input>, usize), ) -> Pattern { (___0) } #[allow(unused_variables)] fn ___action268< 'input, >( text: &'input str, (_, ___0, _): (usize, FieldPattern, usize), ) -> ::std::vec::Vec> { vec![___0] } #[allow(unused_variables)] fn ___action269< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), (_, e, _): (usize, FieldPattern, usize), ) -> ::std::vec::Vec> { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action270< 'input, >( text: &'input str, (_, ___0, _): (usize, Pattern, usize), ) -> ::std::vec::Vec> { vec![___0] } #[allow(unused_variables)] fn ___action271< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), (_, e, _): (usize, Pattern, usize), ) -> ::std::vec::Vec> { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action272< 'input, >( text: &'input str, (_, ___0, _): (usize, Conversion, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action273< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, Conversion, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action274< 'input, >( text: &'input str, (_, ___0, _): (usize, MatchItem, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action275< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, MatchItem, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action276< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeRef, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action277< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, TypeRef, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action278< 'input, >( text: &'input str, (_, ___0, _): (usize, Symbol, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action279< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, Symbol, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action280< 'input, >( text: &'input str, (_, ___0, _): (usize, Alternative, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action281< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, Alternative, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action282< 'input, >( text: &'input str, (_, ___0, _): (usize, NonterminalString, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action283< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, NonterminalString, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action284< 'input, >( text: &'input str, (_, ___0, _): (usize, Parameter, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action285< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, Parameter, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action286< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeBoundParameter, usize), ) -> ::std::vec::Vec> { vec![___0] } #[allow(unused_variables)] fn ___action287< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), (_, e, _): (usize, TypeBoundParameter, usize), ) -> ::std::vec::Vec> { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action288< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeRef, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action289< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, TypeRef, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action290< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeBound, usize), ) -> ::std::vec::Vec> { vec![___0] } #[allow(unused_variables)] fn ___action291< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), (_, e, _): (usize, TypeBound, usize), ) -> ::std::vec::Vec> { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action292< 'input, >( text: &'input str, (_, ___0, _): (usize, Lifetime, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action293< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, Lifetime, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action294< 'input, >( text: &'input str, (_, ___0, _): (usize, WhereClause, usize), ) -> ::std::vec::Vec> { vec![___0] } #[allow(unused_variables)] fn ___action295< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec>, usize), (_, e, _): (usize, WhereClause, usize), ) -> ::std::vec::Vec> { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action296< 'input, >( text: &'input str, (_, ___0, _): (usize, TypeParameter, usize), ) -> ::std::vec::Vec { vec![___0] } #[allow(unused_variables)] fn ___action297< 'input, >( text: &'input str, (_, v, _): (usize, ::std::vec::Vec, usize), (_, e, _): (usize, TypeParameter, usize), ) -> ::std::vec::Vec { { let mut v = v; v.push(e); v } } #[allow(unused_variables)] fn ___action298< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Atom, usize), ) -> Path { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action132( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action79( text, ___temp0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action299< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Atom, usize), ) -> Path { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action133( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action79( text, ___temp0, ___0, ___1, ) } #[allow(unused_variables)] fn ___action300< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ) -> Vec { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action149( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action39( text, ___0, ___1, ___2, ___temp0, ) } #[allow(unused_variables)] fn ___action301< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Tok<'input>, usize), ) -> Vec { let ___start0 = ___2.2.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action150( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action39( text, ___0, ___1, ___2, ___temp0, ) } #[allow(unused_variables)] fn ___action302< 'input, >( text: &'input str, ___0: (usize, usize, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, usize, usize), ___4: (usize, Atom, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, Symbol, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, usize, usize), ) -> Symbol { let ___start0 = ___2.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action138( text, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action52( text, ___0, ___1, ___temp0, ___3, ___4, ___5, ___6, ___7, ___8, ) } #[allow(unused_variables)] fn ___action303< 'input, >( text: &'input str, ___0: (usize, usize, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, usize, usize), ___3: (usize, Atom, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, Symbol, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, usize, usize), ) -> Symbol { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action139( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action52( text, ___0, ___1, ___temp0, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action304< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, ::std::option::Option, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, TypeRef, usize), ) -> TypeRef { let ___start0 = ___2.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action138( text, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action71( text, ___0, ___1, ___temp0, ___3, ) } #[allow(unused_variables)] fn ___action305< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, ::std::option::Option, usize), ___2: (usize, TypeRef, usize), ) -> TypeRef { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action139( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action71( text, ___0, ___1, ___temp0, ___2, ) } #[allow(unused_variables)] fn ___action306< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, TypeRef, usize), ) -> ::std::option::Option { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action165( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action163( text, ___temp0, ) } #[allow(unused_variables)] fn ___action307< 'input, >( text: &'input str, ___0: (usize, Vec, usize), ___1: (usize, Path, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, TypeRef, usize), ) -> TypeBound { let ___start0 = ___5.0.clone(); let ___end0 = ___6.2.clone(); let ___temp0 = ___action306( text, ___5, ___6, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action17( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ) } #[allow(unused_variables)] fn ___action308< 'input, >( text: &'input str, ___0: (usize, Vec, usize), ___1: (usize, Path, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> TypeBound { let ___start0 = ___4.2.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action164( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action17( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ) } #[allow(unused_variables)] fn ___action309< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Path, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, TypeRef, usize), ) -> TypeRef { let ___start0 = ___6.0.clone(); let ___end0 = ___7.2.clone(); let ___temp0 = ___action306( text, ___6, ___7, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action76( text, ___0, ___1, ___2, ___3, ___4, ___5, ___temp0, ) } #[allow(unused_variables)] fn ___action310< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Path, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> TypeRef { let ___start0 = ___5.2.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action164( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action76( text, ___0, ___1, ___2, ___3, ___4, ___5, ___temp0, ) } #[allow(unused_variables)] fn ___action311< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, TypeRef, usize), ) -> ::std::option::Option { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action157( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action155( text, ___temp0, ) } #[allow(unused_variables)] fn ___action312< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Visibility, usize), ___2: (usize, usize, usize), ___3: (usize, (NonterminalString, Vec), usize), ___4: (usize, usize, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, TypeRef, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___5.0.clone(); let ___end0 = ___6.2.clone(); let ___temp0 = ___action311( text, ___5, ___6, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action32( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___7, ___8, ) } #[allow(unused_variables)] fn ___action313< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Visibility, usize), ___2: (usize, usize, usize), ___3: (usize, (NonterminalString, Vec), usize), ___4: (usize, usize, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___4.2.clone(); let ___end0 = ___5.0.clone(); let ___temp0 = ___action156( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action32( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action314< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec>, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::option::Option>> { let ___start0 = ___0.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action161( text, ___0, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action159( text, ___temp0, ) } #[allow(unused_variables)] fn ___action315< 'input, >( text: &'input str, ___0: (usize, Vec, usize), ___1: (usize, Path, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> TypeBound { let ___start0 = ___2.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action314( text, ___2, ___3, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action18( text, ___0, ___1, ___temp0, ) } #[allow(unused_variables)] fn ___action316< 'input, >( text: &'input str, ___0: (usize, Vec, usize), ___1: (usize, Path, usize), ) -> TypeBound { let ___start0 = ___1.2.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action160( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action18( text, ___0, ___1, ___temp0, ) } #[allow(unused_variables)] fn ___action317< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Condition, usize), ) -> ::std::option::Option { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action146( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action144( text, ___temp0, ) } #[allow(unused_variables)] fn ___action318< 'input, >( text: &'input str, ___0: (usize, usize, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Condition, usize), ___4: (usize, ::std::option::Option, usize), ___5: (usize, usize, usize), ) -> Alternative { let ___start0 = ___2.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action317( text, ___2, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action40( text, ___0, ___1, ___temp0, ___4, ___5, ) } #[allow(unused_variables)] fn ___action319< 'input, >( text: &'input str, ___0: (usize, usize, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::option::Option, usize), ___3: (usize, usize, usize), ) -> Alternative { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action145( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action40( text, ___0, ___1, ___temp0, ___2, ___3, ) } #[allow(unused_variables)] fn ___action320< 'input, >( text: &'input str, ___0: (usize, usize, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Condition, usize), ___3: (usize, ActionKind, usize), ___4: (usize, usize, usize), ) -> Alternative { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action317( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action41( text, ___0, ___temp0, ___3, ___4, ) } #[allow(unused_variables)] fn ___action321< 'input, >( text: &'input str, ___0: (usize, usize, usize), ___1: (usize, ActionKind, usize), ___2: (usize, usize, usize), ) -> Alternative { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action145( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action41( text, ___0, ___temp0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action322< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action168( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action14( text, ___temp0, ) } #[allow(unused_variables)] fn ___action323< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Visibility { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action168( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action31( text, ___temp0, ) } #[allow(unused_variables)] fn ___action324< 'input, >( text: &'input str, ___0: (usize, Alternative, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action238( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action280( text, ___temp0, ) } #[allow(unused_variables)] fn ___action325< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Alternative, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action238( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action281( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action326< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action236( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action151( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action327< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action237( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action151( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action328< 'input, >( text: &'input str, ___0: (usize, Conversion, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action262( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action272( text, ___temp0, ) } #[allow(unused_variables)] fn ___action329< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Conversion, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action262( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action273( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action330< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action260( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action125( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action331< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action261( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action125( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action332< 'input, >( text: &'input str, ___0: (usize, FieldPattern, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action123( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action268( text, ___temp0, ) } #[allow(unused_variables)] fn ___action333< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, FieldPattern, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action123( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action269( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action334< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::option::Option>, usize), ___3: (usize, Tok<'input>, usize), ) -> PatternKind { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action121( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action96( text, ___0, ___1, ___temp0, ___2, ___3, ) } #[allow(unused_variables)] fn ___action335< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec>, usize), ___3: (usize, ::std::option::Option>, usize), ___4: (usize, Tok<'input>, usize), ) -> PatternKind { let ___start0 = ___2.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action122( text, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action96( text, ___0, ___1, ___temp0, ___3, ___4, ) } #[allow(unused_variables)] fn ___action336< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ) -> PatternKind { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action121( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action97( text, ___0, ___1, ___temp0, ___2, ___3, ) } #[allow(unused_variables)] fn ___action337< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Tok<'input>, usize), ) -> PatternKind { let ___start0 = ___2.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action122( text, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action97( text, ___0, ___1, ___temp0, ___3, ___4, ) } #[allow(unused_variables)] fn ___action338< 'input, >( text: &'input str, ___0: (usize, Parameter, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action228( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action284( text, ___temp0, ) } #[allow(unused_variables)] fn ___action339< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Parameter, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action228( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action285( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action340< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action226( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action158( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action341< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action227( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action158( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action342< 'input, >( text: &'input str, ___0: (usize, WhereClause, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action205( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action294( text, ___temp0, ) } #[allow(unused_variables)] fn ___action343< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, WhereClause, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action205( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action295( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action344< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option>, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action203( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action170( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action345< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, ::std::option::Option>, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action204( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action170( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action346< 'input, >( text: &'input str, ___0: (usize, Atom, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action131( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action249( text, ___temp0, ) } #[allow(unused_variables)] fn ___action347< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Atom, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action131( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action250( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action348< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Atom, usize), ) -> Path { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action129( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action298( text, ___0, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action349< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Atom, usize), ) -> Path { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action130( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action298( text, ___0, ___temp0, ___2, ) } #[allow(unused_variables)] fn ___action350< 'input, >( text: &'input str, ___0: (usize, Atom, usize), ) -> Path { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action129( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action299( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action351< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Atom, usize), ) -> Path { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action130( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action299( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action352< 'input, >( text: &'input str, ___0: (usize, Lifetime, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action208( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action292( text, ___temp0, ) } #[allow(unused_variables)] fn ___action353< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Lifetime, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action208( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action293( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action354< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action206( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action169( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action355< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action207( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action169( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action356< 'input, >( text: &'input str, ___0: (usize, MatchItem, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action257( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action274( text, ___temp0, ) } #[allow(unused_variables)] fn ___action357< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, MatchItem, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action257( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action275( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action358< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action255( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action126( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action359< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action256( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action126( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action360< 'input, >( text: &'input str, ___0: (usize, NonterminalString, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action233( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action282( text, ___temp0, ) } #[allow(unused_variables)] fn ___action361< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, NonterminalString, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action233( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action283( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action362< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action231( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action152( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action363< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action232( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action152( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action364< 'input, >( text: &'input str, ___0: (usize, Pattern, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action267( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action270( text, ___temp0, ) } #[allow(unused_variables)] fn ___action365< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, Pattern, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action267( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action271( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action366< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option>, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action265( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action124( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action367< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, ::std::option::Option>, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action266( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action124( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action368< 'input, >( text: &'input str, ___0: (usize, Symbol, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action243( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action278( text, ___temp0, ) } #[allow(unused_variables)] fn ___action369< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Symbol, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action243( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action279( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action370< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action241( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action137( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action371< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action242( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action137( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action372< 'input, >( text: &'input str, ___0: (usize, TypeBound, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action213( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action290( text, ___temp0, ) } #[allow(unused_variables)] fn ___action373< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, TypeBound, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action213( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action291( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action374< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option>, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action211( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action167( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action375< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, ::std::option::Option>, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action212( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action167( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action376< 'input, >( text: &'input str, ___0: (usize, TypeBoundParameter, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action223( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action286( text, ___temp0, ) } #[allow(unused_variables)] fn ___action377< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, TypeBoundParameter, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec> { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action223( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action287( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action378< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option>, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action221( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action162( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action379< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, ::std::option::Option>, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action222( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action162( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action380< 'input, >( text: &'input str, ___0: (usize, TypeParameter, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action200( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action296( text, ___temp0, ) } #[allow(unused_variables)] fn ___action381< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, TypeParameter, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action200( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action297( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action382< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action198( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action171( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action383< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action199( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action171( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action384< 'input, >( text: &'input str, ___0: (usize, TypeRef, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action218( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action288( text, ___temp0, ) } #[allow(unused_variables)] fn ___action385< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, TypeRef, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action218( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action289( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action386< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action216( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action166( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action387< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action217( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action166( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action388< 'input, >( text: &'input str, ___0: (usize, TypeRef, usize), ___1: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action248( text, ___0, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action276( text, ___temp0, ) } #[allow(unused_variables)] fn ___action389< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, TypeRef, usize), ___2: (usize, Tok<'input>, usize), ) -> ::std::vec::Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action248( text, ___1, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action277( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action390< 'input, >( text: &'input str, ___0: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action246( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action134( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action391< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action247( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action134( text, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action392< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Condition, usize), ___3: (usize, ::std::option::Option, usize), ___4: (usize, usize, usize), ) -> Alternative { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action318( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action393< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ___2: (usize, usize, usize), ) -> Alternative { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action319( text, ___temp0, ___0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action394< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Condition, usize), ___2: (usize, ActionKind, usize), ___3: (usize, usize, usize), ) -> Alternative { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action320( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action395< 'input, >( text: &'input str, ___0: (usize, ActionKind, usize), ___1: (usize, usize, usize), ) -> Alternative { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action321( text, ___temp0, ___0, ___1, ) } #[allow(unused_variables)] fn ___action396< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Atom, usize), ___3: (usize, ::std::option::Option<(Atom, String)>, usize), ___4: (usize, usize, usize), ___5: (usize, Tok<'input>, usize), ) -> Annotation { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action34( text, ___0, ___1, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action397< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Atom, usize), ___2: (usize, usize, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, TypeRef, usize), ___5: (usize, Tok<'input>, usize), ) -> AssociatedType { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action92( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action398< 'input, >( text: &'input str, ___0: (usize, NonterminalString, usize), ___1: (usize, ConditionOp, usize), ___2: (usize, Atom, usize), ___3: (usize, usize, usize), ) -> Condition { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action46( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action399< 'input, >( text: &'input str, ___0: (usize, TerminalString, usize), ___1: (usize, &'input str, usize), ___2: (usize, usize, usize), ) -> Result,tok::Error>> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___start1 = ___0.2.clone(); let ___end1 = ___1.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); let ___temp1 = ___action181( text, &___start1, &___end1, ); let ___temp1 = (___start1, ___temp1, ___end1); ___action93( text, ___temp0, ___0, ___temp1, ___1, ___2, ) } #[allow(unused_variables)] fn ___action400< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, TypeRef, usize), ___2: (usize, usize, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> EnumToken { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action91( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action401< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, usize, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::vec::Vec, usize), ___4: (usize, EnumToken, usize), ___5: (usize, ::std::vec::Vec, usize), ___6: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action80( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action402< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, usize, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::vec::Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action81( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action403< 'input, >( text: &'input str, ___0: (usize, Atom, usize), ___1: (usize, usize, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Pattern, usize), ) -> FieldPattern { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action104( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action404< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, usize, usize), ___5: (usize, ::std::option::Option>, usize), ___6: (usize, ::std::option::Option>, usize), ___7: (usize, ::std::option::Option>>, usize), ___8: (usize, Tok<'input>, usize), ___9: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action6( text, ___0, ___1, ___2, ___temp0, ___3, ___4, ___5, ___6, ___7, ___8, ___9, ) } #[allow(unused_variables)] fn ___action405< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, usize, usize), ) -> MatchItem { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action86( text, ___temp0, ___0, ___1, ) } #[allow(unused_variables)] fn ___action406< 'input, >( text: &'input str, ___0: (usize, TerminalLiteral, usize), ___1: (usize, usize, usize), ) -> MatchItem { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action87( text, ___temp0, ___0, ___1, ) } #[allow(unused_variables)] fn ___action407< 'input, >( text: &'input str, ___0: (usize, TerminalLiteral, usize), ___1: (usize, &'input str, usize), ___2: (usize, usize, usize), ) -> Result,tok::Error>> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___start1 = ___0.2.clone(); let ___end1 = ___1.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); let ___temp1 = ___action181( text, &___start1, &___end1, ); let ___temp1 = (___start1, ___temp1, ___end1); ___action88( text, ___temp0, ___0, ___temp1, ___1, ___2, ) } #[allow(unused_variables)] fn ___action408< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, usize, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, MatchContents, usize), ___4: (usize, Tok<'input>, usize), ) -> MatchToken { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action84( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action409< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Visibility, usize), ___2: (usize, (NonterminalString, Vec), usize), ___3: (usize, usize, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, TypeRef, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action312( text, ___0, ___1, ___temp0, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action410< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Visibility, usize), ___2: (usize, (NonterminalString, Vec), usize), ___3: (usize, usize, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action313( text, ___0, ___1, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action411< 'input, >( text: &'input str, ___0: (usize, PatternKind, usize), ___1: (usize, usize, usize), ) -> Pattern { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action94( text, ___temp0, ___0, ___1, ) } #[allow(unused_variables)] fn ___action412< 'input, >( text: &'input str, ___0: (usize, &'input str, usize), ) -> Result,tok::Error>> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action116( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action413< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Atom, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Symbol, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, usize, usize), ) -> Symbol { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___start1 = ___1.2.clone(); let ___end1 = ___2.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); let ___temp1 = ___action181( text, &___start1, &___end1, ); let ___temp1 = (___start1, ___temp1, ___end1); ___action302( text, ___temp0, ___0, ___1, ___temp1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action414< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Atom, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Symbol, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, usize, usize), ) -> Symbol { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___start1 = ___0.2.clone(); let ___end1 = ___1.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); let ___temp1 = ___action181( text, &___start1, &___end1, ); let ___temp1 = (___start1, ___temp1, ___end1); ___action303( text, ___temp0, ___0, ___temp1, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action415< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Symbol, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, usize, usize), ) -> Symbol { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action53( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action416< 'input, >( text: &'input str, ___0: (usize, SymbolKind, usize), ___1: (usize, usize, usize), ) -> Symbol { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action181( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action60( text, ___temp0, ___0, ___1, ) } #[allow(unused_variables)] fn ___action417< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Condition, usize), ___3: (usize, ::std::option::Option, usize), ) -> Alternative { let ___start0 = ___3.2.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action392( text, ___0, ___1, ___2, ___3, ___temp0, ) } #[allow(unused_variables)] fn ___action418< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::option::Option, usize), ) -> Alternative { let ___start0 = ___1.2.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action393( text, ___0, ___1, ___temp0, ) } #[allow(unused_variables)] fn ___action419< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Condition, usize), ___2: (usize, ActionKind, usize), ) -> Alternative { let ___start0 = ___2.2.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action394( text, ___0, ___1, ___2, ___temp0, ) } #[allow(unused_variables)] fn ___action420< 'input, >( text: &'input str, ___0: (usize, ActionKind, usize), ) -> Alternative { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action395( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action421< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Atom, usize), ___3: (usize, ::std::option::Option<(Atom, String)>, usize), ___4: (usize, Tok<'input>, usize), ) -> Annotation { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action396( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ) } #[allow(unused_variables)] fn ___action422< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Atom, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, TypeRef, usize), ___4: (usize, Tok<'input>, usize), ) -> AssociatedType { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action397( text, ___0, ___1, ___temp0, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action423< 'input, >( text: &'input str, ___0: (usize, NonterminalString, usize), ___1: (usize, ConditionOp, usize), ___2: (usize, Atom, usize), ) -> Condition { let ___start0 = ___2.2.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action398( text, ___0, ___1, ___2, ___temp0, ) } #[allow(unused_variables)] fn ___action424< 'input, >( text: &'input str, ___0: (usize, TerminalString, usize), ___1: (usize, &'input str, usize), ) -> Result,tok::Error>> { let ___start0 = ___1.2.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action399( text, ___0, ___1, ___temp0, ) } #[allow(unused_variables)] fn ___action425< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, TypeRef, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> EnumToken { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action400( text, ___0, ___1, ___temp0, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action426< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, EnumToken, usize), ___4: (usize, ::std::vec::Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action401( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action427< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action402( text, ___0, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action428< 'input, >( text: &'input str, ___0: (usize, Atom, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Pattern, usize), ) -> FieldPattern { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action403( text, ___0, ___temp0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action429< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, ::std::option::Option>, usize), ___6: (usize, ::std::option::Option>>, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action404( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ___6, ___7, ___8, ) } #[allow(unused_variables)] fn ___action430< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ) -> MatchItem { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action405( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action431< 'input, >( text: &'input str, ___0: (usize, TerminalLiteral, usize), ) -> MatchItem { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action406( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action432< 'input, >( text: &'input str, ___0: (usize, TerminalLiteral, usize), ___1: (usize, &'input str, usize), ) -> Result,tok::Error>> { let ___start0 = ___1.2.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action407( text, ___0, ___1, ___temp0, ) } #[allow(unused_variables)] fn ___action433< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, MatchContents, usize), ___3: (usize, Tok<'input>, usize), ) -> MatchToken { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action408( text, ___0, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action434< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Visibility, usize), ___2: (usize, (NonterminalString, Vec), usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, TypeRef, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action409( text, ___0, ___1, ___2, ___temp0, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action435< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Visibility, usize), ___2: (usize, (NonterminalString, Vec), usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action410( text, ___0, ___1, ___2, ___temp0, ___3, ___4, ) } #[allow(unused_variables)] fn ___action436< 'input, >( text: &'input str, ___0: (usize, PatternKind, usize), ) -> Pattern { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action411( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action437< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Atom, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Symbol, usize), ___5: (usize, Tok<'input>, usize), ) -> Symbol { let ___start0 = ___5.2.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action413( text, ___0, ___1, ___2, ___3, ___4, ___5, ___temp0, ) } #[allow(unused_variables)] fn ___action438< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Atom, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Symbol, usize), ___4: (usize, Tok<'input>, usize), ) -> Symbol { let ___start0 = ___4.2.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action414( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ) } #[allow(unused_variables)] fn ___action439< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Symbol, usize), ___2: (usize, Tok<'input>, usize), ) -> Symbol { let ___start0 = ___2.2.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action415( text, ___0, ___1, ___2, ___temp0, ) } #[allow(unused_variables)] fn ___action440< 'input, >( text: &'input str, ___0: (usize, Symbol, usize), ___1: (usize, RepeatOp, usize), ) -> Symbol { let ___start0 = ___1.2.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action56( text, ___0, ___1, ___temp0, ) } #[allow(unused_variables)] fn ___action441< 'input, >( text: &'input str, ___0: (usize, SymbolKind, usize), ) -> Symbol { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action180( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action416( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action442< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Condition, usize), ___3: (usize, ActionKind, usize), ) -> Alternative { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action142( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action417( text, ___0, ___1, ___2, ___temp0, ) } #[allow(unused_variables)] fn ___action443< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Condition, usize), ) -> Alternative { let ___start0 = ___2.2.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action143( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action417( text, ___0, ___1, ___2, ___temp0, ) } #[allow(unused_variables)] fn ___action444< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ActionKind, usize), ) -> Alternative { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action142( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action418( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action445< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Alternative { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action143( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action418( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action446< 'input, >( text: &'input str, ___0: (usize, Alternative, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action234( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action326( text, ___temp0, ) } #[allow(unused_variables)] fn ___action447< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action235( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action326( text, ___temp0, ) } #[allow(unused_variables)] fn ___action448< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Alternative, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action234( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action327( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action449< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action235( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action327( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action450< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::option::Option>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action182( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action429( text, ___0, ___1, ___temp0, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action451< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, ::std::option::Option>, usize), ___6: (usize, ::std::option::Option>>, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___2.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action183( text, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action429( text, ___0, ___1, ___temp0, ___3, ___4, ___5, ___6, ___7, ___8, ) } #[allow(unused_variables)] fn ___action452< 'input, >( text: &'input str, ___0: (usize, Visibility, usize), ___1: (usize, (NonterminalString, Vec), usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, TypeRef, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action182( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action434( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action453< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Visibility, usize), ___2: (usize, (NonterminalString, Vec), usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, TypeRef, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action183( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action434( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action454< 'input, >( text: &'input str, ___0: (usize, Visibility, usize), ___1: (usize, (NonterminalString, Vec), usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action182( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action435( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action455< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Visibility, usize), ___2: (usize, (NonterminalString, Vec), usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ) -> GrammarItem { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action183( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action435( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action456< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Atom, usize), ___3: (usize, (Atom, String), usize), ___4: (usize, Tok<'input>, usize), ) -> Annotation { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action153( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action421( text, ___0, ___1, ___2, ___temp0, ___4, ) } #[allow(unused_variables)] fn ___action457< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Atom, usize), ___3: (usize, Tok<'input>, usize), ) -> Annotation { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action154( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action421( text, ___0, ___1, ___2, ___temp0, ___3, ) } #[allow(unused_variables)] fn ___action458< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, EnumToken, usize), ___3: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___start1 = ___2.2.clone(); let ___end1 = ___3.0.clone(); let ___temp0 = ___action127( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); let ___temp1 = ___action127( text, &___start1, &___end1, ); let ___temp1 = (___start1, ___temp1, ___end1); ___action426( text, ___0, ___1, ___temp0, ___2, ___temp1, ___3, ) } #[allow(unused_variables)] fn ___action459< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, EnumToken, usize), ___3: (usize, ::std::vec::Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___start1 = ___3.0.clone(); let ___end1 = ___3.2.clone(); let ___temp0 = ___action127( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); let ___temp1 = ___action128( text, ___3, ); let ___temp1 = (___start1, ___temp1, ___end1); ___action426( text, ___0, ___1, ___temp0, ___2, ___temp1, ___4, ) } #[allow(unused_variables)] fn ___action460< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, EnumToken, usize), ___4: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___2.0.clone(); let ___end0 = ___2.2.clone(); let ___start1 = ___3.2.clone(); let ___end1 = ___4.0.clone(); let ___temp0 = ___action128( text, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); let ___temp1 = ___action127( text, &___start1, &___end1, ); let ___temp1 = (___start1, ___temp1, ___end1); ___action426( text, ___0, ___1, ___temp0, ___3, ___temp1, ___4, ) } #[allow(unused_variables)] fn ___action461< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, EnumToken, usize), ___4: (usize, ::std::vec::Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___2.0.clone(); let ___end0 = ___2.2.clone(); let ___start1 = ___4.0.clone(); let ___end1 = ___4.2.clone(); let ___temp0 = ___action128( text, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); let ___temp1 = ___action128( text, ___4, ); let ___temp1 = (___start1, ___temp1, ___end1); ___action426( text, ___0, ___1, ___temp0, ___3, ___temp1, ___5, ) } #[allow(unused_variables)] fn ___action462< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action127( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action427( text, ___0, ___1, ___temp0, ___2, ) } #[allow(unused_variables)] fn ___action463< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> GrammarItem { let ___start0 = ___2.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action128( text, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action427( text, ___0, ___1, ___temp0, ___3, ) } #[allow(unused_variables)] fn ___action464< 'input, >( text: &'input str, ___0: (usize, Conversion, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action258( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action330( text, ___temp0, ) } #[allow(unused_variables)] fn ___action465< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action259( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action330( text, ___temp0, ) } #[allow(unused_variables)] fn ___action466< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Conversion, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action258( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action331( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action467< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action259( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action331( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action468< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, FieldPattern, usize), ___3: (usize, Tok<'input>, usize), ) -> PatternKind { let ___start0 = ___2.0.clone(); let ___end0 = ___2.2.clone(); let ___temp0 = ___action119( text, ___2, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action334( text, ___0, ___1, ___temp0, ___3, ) } #[allow(unused_variables)] fn ___action469< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ) -> PatternKind { let ___start0 = ___1.2.clone(); let ___end0 = ___2.0.clone(); let ___temp0 = ___action120( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action334( text, ___0, ___1, ___temp0, ___2, ) } #[allow(unused_variables)] fn ___action470< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec>, usize), ___3: (usize, FieldPattern, usize), ___4: (usize, Tok<'input>, usize), ) -> PatternKind { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action119( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action335( text, ___0, ___1, ___2, ___temp0, ___4, ) } #[allow(unused_variables)] fn ___action471< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec>, usize), ___3: (usize, Tok<'input>, usize), ) -> PatternKind { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action120( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action335( text, ___0, ___1, ___2, ___temp0, ___3, ) } #[allow(unused_variables)] fn ___action472< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, TypeRef, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, Vec>, usize), ) -> WhereClause { let ___start0 = ___0.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action13( text, ___0, ___1, ___2, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action12( text, ___temp0, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action473< 'input, >( text: &'input str, ___0: (usize, TypeRef, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ) -> WhereClause { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action322( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action12( text, ___temp0, ___0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action474< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Path, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, Vec, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, Tok<'input>, usize), ___9: (usize, TypeRef, usize), ) -> TypeBound { let ___start0 = ___0.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action13( text, ___0, ___1, ___2, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action307( text, ___temp0, ___4, ___5, ___6, ___7, ___8, ___9, ) } #[allow(unused_variables)] fn ___action475< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, TypeRef, usize), ) -> TypeBound { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action322( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action307( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action476< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Path, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, Vec, usize), ___7: (usize, Tok<'input>, usize), ) -> TypeBound { let ___start0 = ___0.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action13( text, ___0, ___1, ___2, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action308( text, ___temp0, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action477< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> TypeBound { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action322( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action308( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action478< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Path, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, Vec>, usize), ___7: (usize, Tok<'input>, usize), ) -> TypeBound { let ___start0 = ___0.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action13( text, ___0, ___1, ___2, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action315( text, ___temp0, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action479< 'input, >( text: &'input str, ___0: (usize, Path, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ) -> TypeBound { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action322( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action315( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action480< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Path, usize), ) -> TypeBound { let ___start0 = ___0.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action13( text, ___0, ___1, ___2, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action316( text, ___temp0, ___4, ) } #[allow(unused_variables)] fn ___action481< 'input, >( text: &'input str, ___0: (usize, Path, usize), ) -> TypeBound { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action322( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action316( text, ___temp0, ___0, ) } #[allow(unused_variables)] fn ___action482< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, Path, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, Vec, usize), ___8: (usize, Tok<'input>, usize), ___9: (usize, Tok<'input>, usize), ___10: (usize, TypeRef, usize), ) -> TypeRef { let ___start0 = ___1.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action13( text, ___1, ___2, ___3, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action309( text, ___0, ___temp0, ___5, ___6, ___7, ___8, ___9, ___10, ) } #[allow(unused_variables)] fn ___action483< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Path, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, TypeRef, usize), ) -> TypeRef { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action322( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action309( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action484< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, Path, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, Vec, usize), ___8: (usize, Tok<'input>, usize), ) -> TypeRef { let ___start0 = ___1.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action13( text, ___1, ___2, ___3, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action310( text, ___0, ___temp0, ___5, ___6, ___7, ___8, ) } #[allow(unused_variables)] fn ___action485< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Path, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> TypeRef { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action322( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action310( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action486< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::option::Option>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___6.2.clone(); let ___end0 = ___6.2.clone(); let ___temp0 = ___action172( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action450( text, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ___temp0, ) } #[allow(unused_variables)] fn ___action487< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::option::Option>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___7.0.clone(); let ___end0 = ___7.2.clone(); let ___temp0 = ___action173( text, ___7, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action450( text, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ___temp0, ) } #[allow(unused_variables)] fn ___action488< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, ::std::option::Option>, usize), ___6: (usize, ::std::option::Option>>, usize), ___7: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___7.2.clone(); let ___end0 = ___7.2.clone(); let ___temp0 = ___action172( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action451( text, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ___temp0, ) } #[allow(unused_variables)] fn ___action489< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, ::std::option::Option>, usize), ___6: (usize, ::std::option::Option>>, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___8.0.clone(); let ___end0 = ___8.2.clone(); let ___temp0 = ___action173( text, ___8, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action451( text, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ___temp0, ) } #[allow(unused_variables)] fn ___action490< 'input, >( text: &'input str, ___0: (usize, Parameter, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action224( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action340( text, ___temp0, ) } #[allow(unused_variables)] fn ___action491< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action225( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action340( text, ___temp0, ) } #[allow(unused_variables)] fn ___action492< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Parameter, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action224( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action341( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action493< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action225( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action341( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action494< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::option::Option>, usize), ___4: (usize, Vec, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action176( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action486( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action495< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::option::Option>, usize), ___4: (usize, ::std::option::Option>>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action177( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action486( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ) } #[allow(unused_variables)] fn ___action496< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::option::Option>, usize), ___4: (usize, Vec, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action176( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action487( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action497< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::option::Option>, usize), ___4: (usize, ::std::option::Option>>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action177( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action487( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action498< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, Vec, usize), ___6: (usize, ::std::option::Option>>, usize), ___7: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___5.0.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action176( text, ___5, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action488( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___6, ___7, ) } #[allow(unused_variables)] fn ___action499< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.2.clone(); let ___end0 = ___5.0.clone(); let ___temp0 = ___action177( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action488( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action500< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, Vec, usize), ___6: (usize, ::std::option::Option>>, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___5.0.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action176( text, ___5, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action489( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___6, ___7, ___8, ) } #[allow(unused_variables)] fn ___action501< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.2.clone(); let ___end0 = ___5.0.clone(); let ___temp0 = ___action177( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action489( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action502< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action178( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action494( text, ___0, ___1, ___2, ___temp0, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action503< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, ::std::option::Option>>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action179( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action494( text, ___0, ___1, ___2, ___temp0, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action504< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, ::std::option::Option>>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action178( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action495( text, ___0, ___1, ___2, ___temp0, ___4, ___5, ) } #[allow(unused_variables)] fn ___action505< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::option::Option>>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action179( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action495( text, ___0, ___1, ___2, ___temp0, ___3, ___4, ) } #[allow(unused_variables)] fn ___action506< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action178( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action496( text, ___0, ___1, ___2, ___temp0, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action507< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, ::std::option::Option>>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action179( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action496( text, ___0, ___1, ___2, ___temp0, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action508< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, ::std::option::Option>>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action178( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action497( text, ___0, ___1, ___2, ___temp0, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action509< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::option::Option>>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action179( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action497( text, ___0, ___1, ___2, ___temp0, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action510< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, ::std::option::Option>>, usize), ___7: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action178( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action498( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action511< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action179( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action498( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action512< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action178( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action499( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action513< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action179( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action499( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ) } #[allow(unused_variables)] fn ___action514< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, ::std::option::Option>>, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action178( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action500( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ___6, ___7, ___8, ) } #[allow(unused_variables)] fn ___action515< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action179( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action500( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action516< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, ::std::option::Option>>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action178( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action501( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action517< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::option::Option>>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action179( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action501( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action518< 'input, >( text: &'input str, ___0: (usize, WhereClause, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action201( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action344( text, ___temp0, ) } #[allow(unused_variables)] fn ___action519< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec> { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action202( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action344( text, ___temp0, ) } #[allow(unused_variables)] fn ___action520< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, WhereClause, usize), ) -> Vec> { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action201( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action345( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action521< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ) -> Vec> { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action202( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action345( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action522< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___5.0.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action174( text, ___5, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action502( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___6, ) } #[allow(unused_variables)] fn ___action523< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.2.clone(); let ___end0 = ___5.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action502( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___5, ) } #[allow(unused_variables)] fn ___action524< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action174( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action503( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ) } #[allow(unused_variables)] fn ___action525< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action503( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ) } #[allow(unused_variables)] fn ___action526< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action174( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action504( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ) } #[allow(unused_variables)] fn ___action527< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action504( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ) } #[allow(unused_variables)] fn ___action528< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action174( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action505( text, ___0, ___1, ___2, ___temp0, ___4, ) } #[allow(unused_variables)] fn ___action529< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action505( text, ___0, ___1, ___2, ___temp0, ___3, ) } #[allow(unused_variables)] fn ___action530< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___5.0.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action174( text, ___5, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action506( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___6, ___7, ) } #[allow(unused_variables)] fn ___action531< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.2.clone(); let ___end0 = ___5.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action506( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action532< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action174( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action507( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action533< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action507( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ) } #[allow(unused_variables)] fn ___action534< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action174( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action508( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action535< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action508( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ) } #[allow(unused_variables)] fn ___action536< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.0.clone(); let ___end0 = ___3.2.clone(); let ___temp0 = ___action174( text, ___3, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action509( text, ___0, ___1, ___2, ___temp0, ___4, ___5, ) } #[allow(unused_variables)] fn ___action537< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___2.2.clone(); let ___end0 = ___3.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action509( text, ___0, ___1, ___2, ___temp0, ___3, ___4, ) } #[allow(unused_variables)] fn ___action538< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Vec>, usize), ___7: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___6.0.clone(); let ___end0 = ___6.2.clone(); let ___temp0 = ___action174( text, ___6, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action510( text, ___0, ___1, ___2, ___3, ___4, ___5, ___temp0, ___7, ) } #[allow(unused_variables)] fn ___action539< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___5.2.clone(); let ___end0 = ___6.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action510( text, ___0, ___1, ___2, ___3, ___4, ___5, ___temp0, ___6, ) } #[allow(unused_variables)] fn ___action540< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___5.0.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action174( text, ___5, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action511( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___6, ) } #[allow(unused_variables)] fn ___action541< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.2.clone(); let ___end0 = ___5.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action511( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___5, ) } #[allow(unused_variables)] fn ___action542< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___5.0.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action174( text, ___5, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action512( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___6, ) } #[allow(unused_variables)] fn ___action543< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.2.clone(); let ___end0 = ___5.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action512( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___5, ) } #[allow(unused_variables)] fn ___action544< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action174( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action513( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ) } #[allow(unused_variables)] fn ___action545< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action513( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ) } #[allow(unused_variables)] fn ___action546< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Vec>, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___6.0.clone(); let ___end0 = ___6.2.clone(); let ___temp0 = ___action174( text, ___6, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action514( text, ___0, ___1, ___2, ___3, ___4, ___5, ___temp0, ___7, ___8, ) } #[allow(unused_variables)] fn ___action547< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___5.2.clone(); let ___end0 = ___6.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action514( text, ___0, ___1, ___2, ___3, ___4, ___5, ___temp0, ___6, ___7, ) } #[allow(unused_variables)] fn ___action548< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___5.0.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action174( text, ___5, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action515( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___6, ___7, ) } #[allow(unused_variables)] fn ___action549< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.2.clone(); let ___end0 = ___5.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action515( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action550< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___5.0.clone(); let ___end0 = ___5.2.clone(); let ___temp0 = ___action174( text, ___5, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action516( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___6, ___7, ) } #[allow(unused_variables)] fn ___action551< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.2.clone(); let ___end0 = ___5.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action516( text, ___0, ___1, ___2, ___3, ___4, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action552< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___4.0.clone(); let ___end0 = ___4.2.clone(); let ___temp0 = ___action174( text, ___4, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action517( text, ___0, ___1, ___2, ___3, ___temp0, ___5, ___6, ) } #[allow(unused_variables)] fn ___action553< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___3.2.clone(); let ___end0 = ___4.0.clone(); let ___temp0 = ___action175( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action517( text, ___0, ___1, ___2, ___3, ___temp0, ___4, ___5, ) } #[allow(unused_variables)] fn ___action554< 'input, >( text: &'input str, ___0: (usize, Lifetime, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action135( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action354( text, ___temp0, ) } #[allow(unused_variables)] fn ___action555< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action136( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action354( text, ___temp0, ) } #[allow(unused_variables)] fn ___action556< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Lifetime, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action135( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action355( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action557< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action136( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action355( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action558< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Lifetime, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, TypeRef, usize), ) -> TypeRef { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action135( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action304( text, ___0, ___temp0, ___2, ___3, ) } #[allow(unused_variables)] fn ___action559< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, TypeRef, usize), ) -> TypeRef { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action136( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action304( text, ___0, ___temp0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action560< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Lifetime, usize), ___2: (usize, TypeRef, usize), ) -> TypeRef { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action135( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action305( text, ___0, ___temp0, ___2, ) } #[allow(unused_variables)] fn ___action561< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, TypeRef, usize), ) -> TypeRef { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action136( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action305( text, ___0, ___temp0, ___1, ) } #[allow(unused_variables)] fn ___action562< 'input, >( text: &'input str, ___0: (usize, MatchItem, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action253( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action358( text, ___temp0, ) } #[allow(unused_variables)] fn ___action563< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action254( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action358( text, ___temp0, ) } #[allow(unused_variables)] fn ___action564< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, MatchItem, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action253( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action359( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action565< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action254( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action359( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action566< 'input, >( text: &'input str, ___0: (usize, NonterminalString, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action229( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action362( text, ___temp0, ) } #[allow(unused_variables)] fn ___action567< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action230( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action362( text, ___temp0, ) } #[allow(unused_variables)] fn ___action568< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, NonterminalString, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action229( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action363( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action569< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action230( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action363( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action570< 'input, >( text: &'input str, ___0: (usize, Pattern, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action263( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action366( text, ___temp0, ) } #[allow(unused_variables)] fn ___action571< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec> { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action264( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action366( text, ___temp0, ) } #[allow(unused_variables)] fn ___action572< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, Pattern, usize), ) -> Vec> { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action263( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action367( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action573< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ) -> Vec> { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action264( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action367( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action574< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action522( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action575< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action522( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action576< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action523( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action577< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action523( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action578< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action524( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action579< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action524( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action580< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action525( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action581< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action525( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action582< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action526( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action583< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action526( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action584< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action527( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action585< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action527( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action586< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action528( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action587< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action528( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action588< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action529( text, ___temp0, ___0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action589< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action529( text, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action590< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action530( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action591< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action530( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action592< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action531( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action593< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action531( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action594< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action532( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action595< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action532( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action596< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action533( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action597< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action533( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action598< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action534( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action599< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action534( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action600< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action535( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action601< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action535( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action602< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action536( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action603< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action536( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action604< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action537( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action605< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action537( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action606< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action538( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action607< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Vec>, usize), ___7: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action538( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action608< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action539( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action609< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action539( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action610< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action540( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action611< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action540( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action612< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action541( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action613< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action541( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action614< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action542( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action615< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action542( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action616< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action543( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action617< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action543( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action618< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action544( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action619< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action544( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action620< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action545( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action621< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action545( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action622< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action546( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action623< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Vec>, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action546( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ___8, ) } #[allow(unused_variables)] fn ___action624< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action547( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action625< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action547( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action626< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action548( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action627< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action548( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action628< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action549( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action629< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action549( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action630< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action550( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action631< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action550( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action632< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action551( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action633< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action551( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action634< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action552( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action635< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action552( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action636< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action186( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action553( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action637< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action187( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action553( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action638< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> ExprSymbol { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action140( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action51( text, ___temp0, ) } #[allow(unused_variables)] fn ___action639< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> ExprSymbol { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action141( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action51( text, ___temp0, ) } #[allow(unused_variables)] fn ___action640< 'input, >( text: &'input str, ___0: (usize, Symbol, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action239( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action370( text, ___temp0, ) } #[allow(unused_variables)] fn ___action641< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action240( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action370( text, ___temp0, ) } #[allow(unused_variables)] fn ___action642< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Symbol, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action239( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action371( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action643< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action240( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action371( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action644< 'input, >( text: &'input str, ___0: (usize, TypeBound, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action209( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action374( text, ___temp0, ) } #[allow(unused_variables)] fn ___action645< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec> { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action210( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action374( text, ___temp0, ) } #[allow(unused_variables)] fn ___action646< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, TypeBound, usize), ) -> Vec> { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action209( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action375( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action647< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ) -> Vec> { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action210( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action375( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action648< 'input, >( text: &'input str, ___0: (usize, TypeBoundParameter, usize), ) -> Vec> { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action219( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action378( text, ___temp0, ) } #[allow(unused_variables)] fn ___action649< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec> { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action220( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action378( text, ___temp0, ) } #[allow(unused_variables)] fn ___action650< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ___1: (usize, TypeBoundParameter, usize), ) -> Vec> { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action219( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action379( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action651< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec>, usize), ) -> Vec> { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action220( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action379( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action652< 'input, >( text: &'input str, ___0: (usize, TypeParameter, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action196( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action382( text, ___temp0, ) } #[allow(unused_variables)] fn ___action653< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action197( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action382( text, ___temp0, ) } #[allow(unused_variables)] fn ___action654< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, TypeParameter, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action196( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action383( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action655< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action197( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action383( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action656< 'input, >( text: &'input str, ___0: (usize, TypeRef, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action214( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action386( text, ___temp0, ) } #[allow(unused_variables)] fn ___action657< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action215( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action386( text, ___temp0, ) } #[allow(unused_variables)] fn ___action658< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, TypeRef, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action214( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action387( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action659< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action215( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action387( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action660< 'input, >( text: &'input str, ___0: (usize, TypeRef, usize), ) -> Vec { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action244( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action390( text, ___temp0, ) } #[allow(unused_variables)] fn ___action661< 'input, >( text: &'input str, ___lookbehind: &usize, ___lookahead: &usize, ) -> Vec { let ___start0 = ___lookbehind.clone(); let ___end0 = ___lookahead.clone(); let ___temp0 = ___action245( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action390( text, ___temp0, ) } #[allow(unused_variables)] fn ___action662< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, TypeRef, usize), ) -> Vec { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action244( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action391( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action663< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ) -> Vec { let ___start0 = ___0.2.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action245( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action391( text, ___0, ___temp0, ) } #[allow(unused_variables)] fn ___action664< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action574( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action665< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action574( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action666< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action575( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action667< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action575( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action668< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action576( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action669< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action576( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action670< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action577( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action671< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action577( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action672< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action578( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action673< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action578( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action674< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action579( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action675< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action579( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action676< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action580( text, ___temp0, ___0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action677< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action580( text, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action678< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action581( text, ___0, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action679< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action581( text, ___0, ___temp0, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action680< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action582( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action681< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action582( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action682< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action583( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action683< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action583( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action684< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action584( text, ___temp0, ___0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action685< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action584( text, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action686< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action585( text, ___0, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action687< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action585( text, ___0, ___temp0, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action688< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec>, usize), ___2: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action586( text, ___temp0, ___0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action689< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action586( text, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action690< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action587( text, ___0, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action691< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action587( text, ___0, ___temp0, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action692< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action588( text, ___temp0, ___0, ___1, ) } #[allow(unused_variables)] fn ___action693< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action588( text, ___temp0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action694< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action589( text, ___0, ___temp0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action695< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action589( text, ___0, ___temp0, ___2, ___3, ) } #[allow(unused_variables)] fn ___action696< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action590( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action697< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action590( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action698< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action591( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action699< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action591( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action700< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action592( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action701< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action592( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action702< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action593( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action703< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action593( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action704< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action594( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action705< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action594( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action706< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action595( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action707< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action595( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action708< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action596( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action709< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action596( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action710< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action597( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action711< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action597( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action712< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action598( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action713< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action598( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action714< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action599( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action715< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action599( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action716< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action600( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action717< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action600( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action718< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action601( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action719< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action601( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action720< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Vec>, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action602( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action721< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action602( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action722< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action603( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action723< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action603( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action724< 'input, >( text: &'input str, ___0: (usize, Tok<'input>, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action604( text, ___temp0, ___0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action725< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action604( text, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action726< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action605( text, ___0, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action727< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action605( text, ___0, ___temp0, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action728< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action606( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action729< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action606( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action730< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action607( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action731< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Vec>, usize), ___7: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action607( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action732< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action608( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action733< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action608( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action734< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action609( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action735< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action609( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action736< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action610( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action737< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action610( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action738< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action611( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action739< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action611( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action740< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action612( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action741< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action612( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action742< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action613( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action743< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action613( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action744< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action614( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action745< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action614( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action746< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action615( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action747< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action615( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action748< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action616( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action749< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action616( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action750< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action617( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action751< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action617( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action752< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action618( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action753< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action618( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action754< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action619( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action755< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action619( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action756< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action620( text, ___temp0, ___0, ___1, ___2, ) } #[allow(unused_variables)] fn ___action757< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action620( text, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action758< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action621( text, ___0, ___temp0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action759< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Tok<'input>, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action621( text, ___0, ___temp0, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action760< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action622( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action761< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action622( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action762< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action623( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action763< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Vec>, usize), ___7: (usize, Tok<'input>, usize), ___8: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action623( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ___7, ___8, ) } #[allow(unused_variables)] fn ___action764< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action624( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action765< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action624( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action766< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action625( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action767< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action625( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action768< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action626( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action769< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action626( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action770< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action627( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action771< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action627( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action772< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action628( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action773< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action628( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action774< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action629( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action775< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action629( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action776< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action630( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action777< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action630( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action778< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action631( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action779< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Vec>, usize), ___6: (usize, Tok<'input>, usize), ___7: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action631( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ___7, ) } #[allow(unused_variables)] fn ___action780< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action632( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action781< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action632( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action782< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action633( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action783< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action633( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action784< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Vec>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action634( text, ___temp0, ___0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action785< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action634( text, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action786< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Vec>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action635( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ___5, ) } #[allow(unused_variables)] fn ___action787< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Vec>, usize), ___5: (usize, Tok<'input>, usize), ___6: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action635( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ___6, ) } #[allow(unused_variables)] fn ___action788< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, Tok<'input>, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action636( text, ___temp0, ___0, ___1, ___2, ___3, ) } #[allow(unused_variables)] fn ___action789< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.0.clone(); let ___end0 = ___0.2.clone(); let ___temp0 = ___action185( text, ___0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action636( text, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action790< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, Tok<'input>, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___0.2.clone(); let ___end0 = ___1.0.clone(); let ___temp0 = ___action184( text, &___start0, &___end0, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action637( text, ___0, ___temp0, ___1, ___2, ___3, ___4, ) } #[allow(unused_variables)] fn ___action791< 'input, >( text: &'input str, ___0: (usize, ::std::vec::Vec, usize), ___1: (usize, ::std::vec::Vec, usize), ___2: (usize, ::std::vec::Vec, usize), ___3: (usize, Tok<'input>, usize), ___4: (usize, Tok<'input>, usize), ___5: (usize, ::std::vec::Vec, usize), ) -> Grammar { let ___start0 = ___1.0.clone(); let ___end0 = ___1.2.clone(); let ___temp0 = ___action185( text, ___1, ); let ___temp0 = (___start0, ___temp0, ___end0); ___action637( text, ___0, ___temp0, ___2, ___3, ___4, ___5, ) } pub trait ___ToTriple<'input, > { fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize), ___lalrpop_util::ParseError, tok::Error>>; } impl<'input, > ___ToTriple<'input, > for (usize, Tok<'input>, usize) { fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize), ___lalrpop_util::ParseError, tok::Error>> { Ok(value) } } impl<'input, > ___ToTriple<'input, > for Result<(usize, Tok<'input>, usize), tok::Error> { fn to_triple(value: Self) -> Result<(usize,Tok<'input>,usize), ___lalrpop_util::ParseError, tok::Error>> { match value { Ok(v) => Ok(v), Err(error) => Err(___lalrpop_util::ParseError::User { error }), } } } lalrpop-0.17.2/src/parser/mod.rs000064400000000000000000000041331346406170700146610ustar0000000000000000use std::iter; use grammar::parse_tree::*; use grammar::pattern::*; use lalrpop_util; use tok; #[cfg(not(feature = "test"))] #[allow(dead_code)] mod lrgrammar; #[cfg(feature = "test")] lalrpop_mod!( #[allow(dead_code)] lrgrammar, "/src/parser/lrgrammar.rs" ); #[cfg(test)] mod test; pub enum Top { Grammar(Grammar), Pattern(Pattern), MatchMapping(TerminalString), TypeRef(TypeRef), GrammarWhereClauses(Vec>), } pub type ParseError<'input> = lalrpop_util::ParseError, tok::Error>; macro_rules! parser { ($input:expr, $offset:expr, $pat:ident, $tok:ident) => {{ let input = $input; let tokenizer = iter::once(Ok((0, tok::Tok::$tok, 0))).chain(tok::Tokenizer::new(input, $offset)); lrgrammar::TopParser::new() .parse(input, tokenizer) .map(|top| match top { Top::$pat(x) => x, _ => unreachable!(), }) }}; } pub fn parse_grammar<'input>(input: &'input str) -> Result> { let mut grammar = parser!(input, 0, Grammar, StartGrammar)?; // find a unique prefix that does not appear anywhere in the input while input.contains(&grammar.prefix) { grammar.prefix.push('_'); } Ok(grammar) } fn parse_pattern<'input>( input: &'input str, offset: usize, ) -> Result, ParseError<'input>> { parser!(input, offset, Pattern, StartPattern) } fn parse_match_mapping<'input>( input: &'input str, offset: usize, ) -> Result> { parser!(input, offset, MatchMapping, StartMatchMapping) } #[cfg(test)] pub fn parse_type_ref<'input>(input: &'input str) -> Result> { parser!(input, 0, TypeRef, StartTypeRef) } #[cfg(test)] pub fn parse_where_clauses<'input>( input: &'input str, ) -> Result>, ParseError<'input>> { parser!(input, 0, GrammarWhereClauses, StartGrammarWhereClauses) } lalrpop-0.17.2/src/parser/test.rs000064400000000000000000000132221346225060300150510ustar0000000000000000use grammar::parse_tree::{GrammarItem, MatchItem}; use parser; #[test] fn match_block() { let blocks = vec![ r#"grammar; match { _ }"#, // Minimal r#"grammar; match { _ } else { _ }"#, // Doesn't really make sense, but should be allowed r#"grammar; match { "abc" }"#, // Single token r#"grammar; match { "abc" => "QUOTED" }"#, // Single token with quoted alias r#"grammar; match { "abc" => UNQUOTED }"#, // Single token with unquoted alias r#"grammar; match { r"(?i)begin" => BEGIN }"#, // Regex r#"grammar; match { "abc", "def" => "DEF", _ } else { "foo" => BAR, r"(?i)begin" => BEGIN, _ }"#, // Complex r#"grammar; match { "abc" } else { "def" } else { _ }"#, // Multi-chain ]; for block in blocks { let parsed = parser::parse_grammar(&block) .expect(format!("Invalid grammar; grammar={}", block).as_str()); let first_item = parsed.items.first().expect("has item"); match *first_item { GrammarItem::MatchToken(_) => (), // OK _ => panic!("expected MatchToken, but was {:?}", first_item), } } } #[test] fn match_complex() { let parsed = parser::parse_grammar( r#" grammar; match { r"(?i)begin" => "BEGIN", r"(?i)end" => "END", } else { r"[a-zA-Z_][a-zA-Z0-9_]*" => IDENTIFIER, } else { "other", _ } "#, ) .unwrap(); // We could probably make some nice system for testing this let first_item = parsed.items.first().expect("has item"); match *first_item { GrammarItem::MatchToken(ref data) => { // match { ... } let contents0 = data.contents.get(0).unwrap(); // r"(?i)begin" => "BEGIN" let item00 = contents0.items.get(0).unwrap(); match *item00 { MatchItem::Mapped(ref sym, ref mapping, _) => { assert_eq!(format!("{:?}", sym), "r#\"(?i)begin\"#"); assert_eq!(format!("{}", mapping), "\"BEGIN\""); } _ => panic!("expected MatchItem::Mapped, but was: {:?}", item00), }; // r"(?i)end" => "END", let item01 = contents0.items.get(1).unwrap(); match *item01 { MatchItem::Mapped(ref sym, ref mapping, _) => { assert_eq!(format!("{:?}", sym), "r#\"(?i)end\"#"); assert_eq!(format!("{}", mapping), "\"END\""); } _ => panic!("expected MatchItem::Mapped, but was: {:?}", item00), }; // else { ... } let contents1 = data.contents.get(1).unwrap(); // r"[a-zA-Z_][a-zA-Z0-9_]*" => IDENTIFIER, let item10 = contents1.items.get(0).unwrap(); match *item10 { MatchItem::Mapped(ref sym, ref mapping, _) => { assert_eq!(format!("{:?}", sym), "r#\"[a-zA-Z_][a-zA-Z0-9_]*\"#"); assert_eq!(format!("{}", mapping), "IDENTIFIER"); } _ => panic!("expected MatchItem::Mapped, but was: {:?}", item10), }; // else { ... } let contents2 = data.contents.get(2).unwrap(); // "other", let item20 = contents2.items.get(0).unwrap(); match *item20 { MatchItem::Unmapped(ref sym, _) => { assert_eq!(format!("{:?}", sym), "\"other\""); } _ => panic!("expected MatchItem::Unmapped, but was: {:?}", item20), }; // _ let item21 = contents2.items.get(1).unwrap(); match *item21 { MatchItem::CatchAll(_) => (), _ => panic!("expected MatchItem::CatchAll, but was: {:?}", item20), }; } _ => panic!("expected MatchToken, but was: {:?}", first_item), } } #[test] fn where_clauses() { let clauses = vec![ "where T: Debug", "where T: Debug + Display", "where T: std::ops::Add", "where T: IntoIterator", "where T: 'a", "where 'a: 'b", "where for<'a> &'a T: Debug", "where T: for<'a> Flobbles<'a>", "where T: FnMut(usize)", "where T: FnMut(usize, bool)", "where T: FnMut() -> bool", "where T: for<'a> FnMut(&'a usize)", "where T: Debug, U: Display", ]; for santa in clauses { assert!( parser::parse_where_clauses(santa).is_ok(), "should parse where clauses: {}", santa ); } } #[test] fn grammars_with_where_clauses() { let grammars = vec![ r###" grammar where T: StaticMethods; "###, r###" grammar(methods: &mut T) where T: MutMethods; "###, r###" grammar<'input, T>(methods: &mut T) where T: 'input + Debug + MutMethods; "###, r###" grammar(methods: &mut F) where F: for<'a> FnMut(&'a usize) -> bool; "###, r###" grammar(logger: &mut F) where F: for<'a> FnMut(&'a str); "###, ]; for g in grammars { assert!(parser::parse_grammar(g).is_ok()); } } #[test] fn optional_semicolon() { // Semi after block is optional let g = r#" grammar; pub Foo: () = { Bar } Bar: () = "bar"; "#; assert!(parser::parse_grammar(g).is_ok()); // Semi after "expression" is mandatory let g = r#" grammar; pub Foo: () = { Bar }; Bar: () = "bar" "#; assert!(parser::parse_grammar(g).is_err()); } lalrpop-0.17.2/src/rust/mod.rs000064400000000000000000000175221346406170700143700ustar0000000000000000//! Simple Rust AST. This is what the various code generators create, //! which then gets serialized. use grammar::parse_tree::Visibility; use grammar::repr::{self, Grammar}; use std::fmt::{self, Display}; use std::io::{self, Write}; use tls::Tls; macro_rules! rust { ($w:expr, $($args:tt)*) => { ($w).writeln(&::std::fmt::format(format_args!($($args)*)))? } } /// A wrapper around a Write instance that handles indentation for /// Rust code. It expects Rust code to be written in a stylized way, /// with lots of braces and newlines (example shown here with no /// indentation). Over time maybe we can extend this to make things /// look prettier, but seems like...meh, just run it through some /// rustfmt tool. /// /// ```ignore /// fn foo( /// arg1: Type1, /// arg2: Type2, /// arg3: Type3) /// -> ReturnType /// { /// match foo { /// Variant => { /// } /// } /// } /// ``` pub struct RustWrite { write: W, indent: usize, } const TAB: usize = 4; impl<'me, W: Write> RustWrite { pub fn new(w: W) -> RustWrite { RustWrite { write: w, indent: 0, } } pub fn into_inner(self) -> W { self.write } fn write_indentation(&mut self) -> io::Result<()> { if Tls::session().emit_whitespace { write!(self.write, "{0:1$}", "", self.indent)?; } Ok(()) } fn write_indented(&mut self, out: &str) -> io::Result<()> { self.write_indentation()?; writeln!(self.write, "{}", out) } pub fn write_table_row(&mut self, iterable: I) -> io::Result<()> where I: IntoIterator, C: fmt::Display, { let session = Tls::session(); if session.emit_comments { for (i, comment) in iterable { self.write_indentation()?; writeln!(self.write, "{}, {}", i, comment)?; } } else { self.write_indentation()?; let mut first = true; for (i, _comment) in iterable { if !first && session.emit_whitespace { write!(self.write, " ")?; } write!(self.write, "{},", i)?; first = false; } } writeln!(self.write) } pub fn writeln(&mut self, out: &str) -> io::Result<()> { let buf = out.as_bytes(); // pass empty lines through with no indentation if buf.is_empty() { return self.write.write_all("\n".as_bytes()); } let n = buf.len() - 1; // If the line begins with a `}`, `]`, or `)`, first decrement the indentation. if buf[0] == b'}' || buf[0] == b']' || buf[0] == b')' { self.indent -= TAB; } self.write_indented(out)?; // Detect a line that ends in a `{` or `(` and increase indentation for future lines. if buf[n] == b'{' || buf[n] == b'[' || buf[n] == b'(' { self.indent += TAB; } Ok(()) } /// Create and return fn-header builder. Don't forget to invoke /// `emit` at the end. =) pub fn fn_header(&'me mut self, visibility: &'me Visibility, name: String) -> FnHeader<'me, W> { FnHeader::new(self, visibility, name) } pub fn write_module_attributes(&mut self, grammar: &Grammar) -> io::Result<()> { for attribute in grammar.module_attributes.iter() { rust!(self, "{}", attribute); } Ok(()) } pub fn write_uses(&mut self, super_prefix: &str, grammar: &Grammar) -> io::Result<()> { // things the user wrote for u in &grammar.uses { if u.starts_with("super::") { rust!(self, "use {}{};", super_prefix, u); } else { rust!(self, "use {};", u); } } self.write_standard_uses(&grammar.prefix) } pub fn write_standard_uses(&mut self, prefix: &str) -> io::Result<()> { // Stuff that we plan to use. // Occasionally we happen to not use it after all, hence the allow. rust!(self, "#[allow(unused_extern_crates)]"); rust!( self, "extern crate lalrpop_util as {p}lalrpop_util;", p = prefix, ); rust!(self, "#[allow(unused_imports)]"); rust!( self, "use self::{p}lalrpop_util::state_machine as {p}state_machine;", p = prefix, ); Ok(()) } } pub struct FnHeader<'me, W: Write + 'me> { write: &'me mut RustWrite, visibility: &'me Visibility, name: String, type_parameters: Vec, parameters: Vec, return_type: String, where_clauses: Vec, } impl<'me, W: Write> FnHeader<'me, W> { pub fn new(write: &'me mut RustWrite, visibility: &'me Visibility, name: String) -> Self { FnHeader { write, visibility, name, type_parameters: vec![], parameters: vec![], return_type: "()".to_string(), where_clauses: vec![], } } /// Adds the type-parameters, where-clauses, and parameters from /// the grammar. pub fn with_grammar(self, grammar: &Grammar) -> Self { self.with_type_parameters(&grammar.type_parameters) .with_where_clauses(&grammar.where_clauses) .with_parameters(&grammar.parameters) } /// Declare a series of type parameters. Note that lifetime /// parameters must come first. pub fn with_type_parameters(mut self, tps: impl IntoIterator) -> Self { self.type_parameters .extend(tps.into_iter().map(|t| t.to_string())); self } /// Add where clauses to the list. pub fn with_where_clauses(mut self, tps: impl IntoIterator) -> Self { self.where_clauses .extend(tps.into_iter().map(|t| t.to_string())); self } /// Declare a series of parameters. You can supply strings of the /// form `"foo: Bar"` or else `repr::Parameter` references. pub fn with_parameters( mut self, parameters: impl IntoIterator, ) -> Self { self.parameters.extend( parameters .into_iter() .map(ParameterDisplay::to_parameter_string), ); self } /// Add where clauses to the list. pub fn with_return_type(mut self, rt: impl Display) -> Self { self.return_type = format!("{}", rt); self } /// Emit fn header -- everything up to the opening `{` for the /// body. pub fn emit(self) -> io::Result<()> { rust!(self.write, "{}fn {}<", self.visibility, self.name); for type_parameter in &self.type_parameters { rust!(self.write, "{0:1$}{2},", "", TAB, type_parameter); } rust!(self.write, ">("); for parameter in &self.parameters { rust!(self.write, "{},", parameter); } rust!(self.write, ") -> {}", self.return_type); if !self.where_clauses.is_empty() { rust!(self.write, "where"); for where_clause in &self.where_clauses { rust!(self.write, " {},", where_clause); } } Ok(()) } } pub trait ParameterDisplay { fn to_parameter_string(self) -> String; } impl ParameterDisplay for String { fn to_parameter_string(self) -> String { self } } impl<'me> ParameterDisplay for &'me repr::Parameter { fn to_parameter_string(self) -> String { format!("{}: {}", self.name, self.ty) } } lalrpop-0.17.2/src/session.rs000064400000000000000000000133161346225060300142650ustar0000000000000000//! Internal configuration and session-specific settings. This is similar //! to `configuration::Configuration`, but it is not exported outside the //! crate. Note that all fields are public and so forth for convenience. use log::{Level, Log}; use std::collections::BTreeSet; use std::default::Default; use std::path; use style::{self, Style}; // These two, ubiquitous types are defined here so that their fields can be private // across crate, but visible within the crate: #[derive(Copy, Clone)] pub enum ColorConfig { /// Use ANSI colors. Yes, /// Do NOT use ANSI colors. No, /// Use them if we detect a TTY output (default). IfTty, } /// Various options to control debug output. Although this struct is /// technically part of LALRPOP's exported interface, it is not /// considered part of the semver guarantees as end-users are not /// expected to use it. #[derive(Clone)] pub struct Session { pub log: Log, pub force_build: bool, pub in_dir: Option, pub out_dir: Option, /// Emit `rerun-if-changed` directives for Cargo pub emit_rerun_directives: bool, /// Emit comments in generated code explaining the states and so /// forth. pub emit_comments: bool, /// Emit whitespace in the generated code to improve readability. pub emit_whitespace: bool, /// Emit report file about generated code pub emit_report: bool, pub color_config: ColorConfig, /// Stop after you find `max_errors` errors. If this value is 0, /// report *all* errors. Note that we MAY always report more than /// this value if we so choose. pub max_errors: usize, // Styles to use when formatting error reports /// Applied to the heading in a message. pub heading: Style, /// Applied to symbols in an ambiguity report (where there is no cursor) pub ambig_symbols: Style, /// Applied to symbols before the cursor in a local ambiguity report pub observed_symbols: Style, /// Applied to symbols at the cursor in a local ambiguity report, /// if it is a non-terminal pub cursor_symbol: Style, /// Applied to symbols after the cursor in a local ambiguity report pub unobserved_symbols: Style, /// Applied to terminal symbols, in addition to the above styles pub terminal_symbol: Style, /// Applied to nonterminal symbols, in addition to the above styles pub nonterminal_symbol: Style, /// Style to use when printing "Hint:" pub hint_text: Style, /// Unit testing (lalrpop-test) configuration pub unit_test: bool, /// Features used for conditional compilation pub features: Option>, } impl Session { pub fn new() -> Session { Session { log: Log::new(Level::Informative), in_dir: None, out_dir: None, force_build: false, emit_rerun_directives: false, emit_comments: false, emit_whitespace: true, emit_report: false, color_config: ColorConfig::default(), max_errors: 1, heading: style::FG_WHITE.with(style::BOLD), ambig_symbols: style::FG_WHITE, observed_symbols: style::FG_BRIGHT_GREEN, cursor_symbol: style::FG_BRIGHT_WHITE, unobserved_symbols: style::FG_BRIGHT_RED, terminal_symbol: style::BOLD, nonterminal_symbol: style::DEFAULT, hint_text: style::FG_BRIGHT_MAGENTA.with(style::BOLD), unit_test: false, features: Default::default(), } } /// A session suitable for use in testing. #[cfg(test)] pub fn test() -> Session { Session { log: Log::new(Level::Debug), in_dir: None, out_dir: None, force_build: false, emit_rerun_directives: false, emit_comments: false, emit_whitespace: true, emit_report: false, color_config: ColorConfig::IfTty, max_errors: 1, heading: Style::new(), ambig_symbols: Style::new(), observed_symbols: Style::new(), cursor_symbol: Style::new(), unobserved_symbols: Style::new(), terminal_symbol: Style::new(), nonterminal_symbol: Style::new(), hint_text: Style::new(), unit_test: true, features: Default::default(), } } /// Indicates whether we should stop after `actual_errors` number /// of errors have been reported. pub fn stop_after(&self, actual_errors: usize) -> bool { self.max_errors != 0 && actual_errors >= self.max_errors } pub fn log(&self, level: Level, message: M) where M: FnOnce() -> String, { self.log.log(level, message) } pub fn emit_rerun_directive(&self, path: &path::Path) { if self.emit_rerun_directives { if let Some(display) = path.to_str() { println!("cargo:rerun-if-changed={}", display) } else { println!("cargo:warning=LALRPOP is unable to inform Cargo that {} is a dependency because its filename cannot be represented in UTF-8. This is probably because it contains an unpaired surrogate character on Windows. As a result, your build script will not be rerun when it changes.", path.to_string_lossy()); } } } } impl Default for Session { fn default() -> Self { Session::new() } } impl Default for ColorConfig { fn default() -> Self { ColorConfig::IfTty } } lalrpop-0.17.2/src/test_util.rs000064400000000000000000000044161346225060300146170ustar0000000000000000use diff; use grammar::parse_tree as pt; use grammar::repr as r; use normalize::NormError; use regex::Regex; use std::fmt::{Debug, Error, Formatter}; thread_local! { static SPAN: Regex = Regex::new(r"Span\([0-9 ,]*\)").unwrap() } struct ExpectedDebug<'a>(&'a str); impl<'a> Debug for ExpectedDebug<'a> { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { // Ignore trailing commas in multiline Debug representation. // Needed to work around rust-lang/rust#59076. let s = self.0.replace(",\n", "\n"); write!(fmt, "{}", s) } } pub fn expect_debug(actual: D, expected: &str) { compare( ExpectedDebug(&format!("{:#?}", actual)), ExpectedDebug(expected), ) } pub fn compare(actual: D, expected: E) { let actual_s = format!("{:?}", actual); let expected_s = format!("{:?}", expected); SPAN.with(|span| { let actual_s = span.replace_all(&actual_s, "Span(..)"); let expected_s = span.replace_all(&expected_s, "Span(..)"); if actual_s != expected_s { let actual_s = format!("{:#?}", actual); let expected_s = format!("{:#?}", expected); for diff in diff::lines(&actual_s, &expected_s) { match diff { diff::Result::Right(r) => println!("- {}", r), diff::Result::Left(l) => println!("+ {}", l), diff::Result::Both(l, _) => println!(" {}", l), } } assert!(false); } }); } pub fn normalized_grammar(s: &str) -> r::Grammar { ::normalize::normalize_without_validating(::parser::parse_grammar(s).unwrap()).unwrap() } pub fn check_norm_err(expected_err: &str, span: &str, err: NormError) { let expected_err = Regex::new(expected_err).unwrap(); let start_index = span.find("~").unwrap(); let end_index = span.rfind("~").unwrap() + 1; assert!(start_index <= end_index); assert_eq!(err.span, pt::Span(start_index, end_index)); assert!( expected_err.is_match(&err.message), "unexpected error text `{}`, which did not match regular expression `{}`", err.message, expected_err ); } lalrpop-0.17.2/src/tls/mod.rs000064400000000000000000000035041346406170700141700ustar0000000000000000//! Certain bits of environmental state are too annoying to thread //! around everywhere, so pack them into TLS. use file_text::FileText; use session::Session; use std::cell::RefCell; use std::rc::Rc; pub struct Tls { _dummy: (), } #[derive(Clone)] struct TlsFields { session: Rc, file_text: Rc, } thread_local! { static THE_TLS_FIELDS: RefCell> = RefCell::new(None) } impl Tls { #[cfg(test)] pub fn test() -> Tls { Self::install(Rc::new(Session::test()), Rc::new(FileText::test())) } #[cfg(test)] pub fn test_string(text: &str) -> Tls { use std::path::PathBuf; Self::install( Rc::new(Session::test()), Rc::new(FileText::new(PathBuf::from("tmp.txt"), String::from(text))), ) } /// Installs `Tls` and returns a placeholder value. When this /// value is dropped, the `Tls` entries will be removed. To access /// the values from `Tls`, call `Tls::session()` or /// `Tls::file_text()`. pub fn install(session: Rc, file_text: Rc) -> Tls { let fields = TlsFields { session, file_text }; THE_TLS_FIELDS.with(|s| { let mut s = s.borrow_mut(); assert!(s.is_none()); *s = Some(fields.clone()); }); Tls { _dummy: () } } fn fields() -> TlsFields { THE_TLS_FIELDS.with(|s| s.borrow().clone().expect("TLS is not installed")) } pub fn session() -> Rc { Self::fields().session } pub fn file_text() -> Rc { Self::fields().file_text } } impl Drop for Tls { fn drop(&mut self) { THE_TLS_FIELDS.with(|s| { *s.borrow_mut() = None; }) } } lalrpop-0.17.2/src/tok/mod.rs000064400000000000000000000635621350346176100141730ustar0000000000000000//! A tokenizer for use in LALRPOP itself. use std::borrow::Cow; use std::str::CharIndices; use unicode_xid::UnicodeXID; use self::ErrorCode::*; use self::Tok::*; #[cfg(test)] mod test; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Error { pub location: usize, pub code: ErrorCode, } #[derive(Clone, Debug, PartialEq, Eq)] pub enum ErrorCode { UnrecognizedToken, UnterminatedEscape, UnrecognizedEscape, UnterminatedStringLiteral, UnterminatedCharacterLiteral, UnterminatedAttribute, UnterminatedCode, ExpectedStringLiteral, } fn error(c: ErrorCode, l: usize) -> Result { Err(Error { location: l, code: c, }) } #[derive(Clone, Debug, PartialEq, Eq)] pub enum Tok<'input> { // Keywords; Enum, Extern, Grammar, Match, Else, If, Mut, Pub, Type, Where, For, Dyn, // Special keywords: these are accompanied by a series of // uninterpreted strings representing imports and stuff. Use(&'input str), // Identifiers of various kinds: Escape(&'input str), Id(&'input str), MacroId(&'input str), // identifier followed immediately by `<` Lifetime(&'input str), // includes the `'` StringLiteral(&'input str), // excludes the `"` CharLiteral(&'input str), // excludes the `'` RegexLiteral(&'input str), // excludes the `r"` and `"` // Symbols: Ampersand, BangEquals, BangTilde, Colon, ColonColon, Comma, DotDot, Equals, EqualsEquals, EqualsGreaterThanCode(&'input str), EqualsGreaterThanQuestionCode(&'input str), EqualsGreaterThanLookahead, EqualsGreaterThanLookbehind, Hash, GreaterThan, LeftBrace, LeftBracket, LeftParen, LessThan, Lookahead, // @L Lookbehind, // @R MinusGreaterThan, Plus, Question, RightBrace, RightBracket, RightParen, Semi, Star, TildeTilde, Underscore, Bang, ShebangAttribute(&'input str), // #![...] // Dummy tokens for parser sharing StartGrammar, StartPattern, StartMatchMapping, #[allow(dead_code)] StartGrammarWhereClauses, #[allow(dead_code)] StartTypeRef, } pub struct Tokenizer<'input> { text: &'input str, chars: CharIndices<'input>, lookahead: Option<(usize, char)>, shift: usize, } pub type Spanned = (usize, T, usize); const KEYWORDS: &[(&str, Tok<'static>)] = &[ ("enum", Enum), ("extern", Extern), ("grammar", Grammar), ("match", Match), ("else", Else), ("if", If), ("mut", Mut), ("pub", Pub), ("type", Type), ("where", Where), ("for", For), ("dyn", Dyn), ]; // Helper for backtracking. macro_rules! first { ($this:expr, $action:expr, $fallback:expr) => {{ let fallback_state = ($this.chars.clone(), $this.lookahead); let result = $action; match result { Ok(_) => Some(result), _ => { $this.chars = fallback_state.0; $this.lookahead = fallback_state.1; Some($fallback) } } }}; } macro_rules! try_opt { ($e:expr, $err:expr) => {{ let r = $e; match r { Some(Ok(val)) => val, Some(Err(err)) => return Err(err), None => return $err, } }}; } impl<'input> Tokenizer<'input> { pub fn new(text: &'input str, shift: usize) -> Tokenizer<'input> { let mut t = Tokenizer { text, chars: text.char_indices(), lookahead: None, shift, }; t.bump(); t } fn shebang_attribute(&mut self, idx0: usize) -> Result>, Error> { try_opt!( self.expect_char('!'), error(ErrorCode::UnrecognizedToken, idx0) ); try_opt!( self.expect_char('['), error(ErrorCode::UnterminatedAttribute, idx0) ); let mut sq_bracket_counter = 1; while let Some((idx1, c)) = self.lookahead { match c { '[' => { self.bump(); sq_bracket_counter += 1 } ']' => { self.bump(); sq_bracket_counter -= 1; match sq_bracket_counter { 0 => { let idx2 = idx1 + 1; let data = &self.text[idx0..idx2]; self.bump(); return Ok((idx0, ShebangAttribute(data), idx2)); } n if n < 0 => return error(UnrecognizedToken, idx0), _ => (), } } '"' => { self.bump(); let _ = self.string_literal(idx1)?; } '\n' => return error(UnrecognizedToken, idx0), _ => { self.bump(); } } } error(UnrecognizedToken, idx0) } fn next_unshifted(&mut self) -> Option>, Error>> { loop { return match self.lookahead { Some((idx0, '&')) => { self.bump(); Some(Ok((idx0, Ampersand, idx0 + 1))) } Some((idx0, '!')) => match self.bump() { Some((idx1, '=')) => { self.bump(); Some(Ok((idx0, BangEquals, idx1 + 1))) } Some((idx1, '~')) => { self.bump(); Some(Ok((idx0, BangTilde, idx1 + 1))) } _ => Some(Ok((idx0, Bang, idx0 + 1))), }, Some((idx0, ':')) => match self.bump() { Some((idx1, ':')) => { self.bump(); Some(Ok((idx0, ColonColon, idx1 + 1))) } _ => Some(Ok((idx0, Colon, idx0 + 1))), }, Some((idx0, ',')) => { self.bump(); Some(Ok((idx0, Comma, idx0 + 1))) } Some((idx0, '.')) => match self.bump() { Some((idx1, '.')) => { self.bump(); Some(Ok((idx0, DotDot, idx1 + 1))) } _ => Some(error(UnrecognizedToken, idx0)), }, Some((idx0, '=')) => match self.bump() { Some((idx1, '=')) => { self.bump(); Some(Ok((idx0, EqualsEquals, idx1 + 1))) } Some((_, '>')) => { self.bump(); Some(self.right_arrow(idx0)) } _ => Some(Ok((idx0, Equals, idx0 + 1))), }, Some((idx0, '#')) => { self.bump(); first!(self, { self.shebang_attribute(idx0) }, { Ok((idx0, Hash, idx0 + 1)) }) } Some((idx0, '>')) => { self.bump(); Some(Ok((idx0, GreaterThan, idx0 + 1))) } Some((idx0, '{')) => { self.bump(); Some(Ok((idx0, LeftBrace, idx0 + 1))) } Some((idx0, '[')) => { self.bump(); Some(Ok((idx0, LeftBracket, idx0 + 1))) } Some((idx0, '(')) => { self.bump(); Some(Ok((idx0, LeftParen, idx0 + 1))) } Some((idx0, '<')) => { self.bump(); Some(Ok((idx0, LessThan, idx0 + 1))) } Some((idx0, '@')) => match self.bump() { Some((idx1, 'L')) => { self.bump(); Some(Ok((idx0, Lookahead, idx1 + 1))) } Some((idx1, 'R')) => { self.bump(); Some(Ok((idx0, Lookbehind, idx1 + 1))) } _ => Some(error(UnrecognizedToken, idx0)), }, Some((idx0, '+')) => { self.bump(); Some(Ok((idx0, Plus, idx0 + 1))) } Some((idx0, '?')) => { self.bump(); Some(Ok((idx0, Question, idx0 + 1))) } Some((idx0, '}')) => { self.bump(); Some(Ok((idx0, RightBrace, idx0 + 1))) } Some((idx0, ']')) => { self.bump(); Some(Ok((idx0, RightBracket, idx0 + 1))) } Some((idx0, ')')) => { self.bump(); Some(Ok((idx0, RightParen, idx0 + 1))) } Some((idx0, ';')) => { self.bump(); Some(Ok((idx0, Semi, idx0 + 1))) } Some((idx0, '*')) => { self.bump(); Some(Ok((idx0, Star, idx0 + 1))) } Some((idx0, '~')) => match self.bump() { Some((idx1, '~')) => { self.bump(); Some(Ok((idx0, TildeTilde, idx1 + 1))) } _ => Some(error(UnrecognizedToken, idx0)), }, Some((idx0, '`')) => { self.bump(); Some(self.escape(idx0)) } Some((idx0, '\'')) => { self.bump(); Some(self.lifetimeish(idx0)) } Some((idx0, '"')) => { self.bump(); Some(self.string_literal(idx0)) } Some((idx0, '/')) => match self.bump() { Some((_, '/')) => { self.take_until(|c| c == '\n'); continue; } _ => Some(error(UnrecognizedToken, idx0)), }, Some((idx0, '-')) => match self.bump() { Some((idx1, '>')) => { self.bump(); Some(Ok((idx0, MinusGreaterThan, idx1 + 1))) } _ => Some(error(UnrecognizedToken, idx0)), }, Some((idx0, c)) if is_identifier_start(c) => { if c == 'r' { // watch out for r"..." or r#"..."# strings self.bump(); match self.lookahead { Some((_, '#')) | Some((_, '"')) => Some(self.regex_literal(idx0)), _ => { // due to the particulars of how identifierish works, // it's ok that we already consumed the 'r', because the // identifier will run from idx0 (the 'r') to the end Some(self.identifierish(idx0)) } } } else { Some(self.identifierish(idx0)) } } Some((_, c)) if c.is_whitespace() => { self.bump(); continue; } Some((idx, _)) => Some(error(UnrecognizedToken, idx)), None => None, }; } } fn bump(&mut self) -> Option<(usize, char)> { self.lookahead = self.chars.next(); self.lookahead } fn right_arrow(&mut self, idx0: usize) -> Result>, Error> { // we've seen =>, now we have to choose between: // // => code // =>? code // =>@L // =>@R match self.lookahead { Some((_, '@')) => match self.bump() { Some((idx2, 'L')) => { self.bump(); Ok((idx0, EqualsGreaterThanLookahead, idx2 + 1)) } Some((idx2, 'R')) => { self.bump(); Ok((idx0, EqualsGreaterThanLookbehind, idx2 + 1)) } _ => error(UnrecognizedToken, idx0), }, Some((idx1, '?')) => { self.bump(); let idx2 = self.code(idx0, "([{", "}])")?; let code = &self.text[idx1 + 1..idx2]; Ok((idx0, EqualsGreaterThanQuestionCode(code), idx2)) } Some((idx1, _)) => { let idx2 = self.code(idx0, "([{", "}])")?; let code = &self.text[idx1..idx2]; Ok((idx0, EqualsGreaterThanCode(code), idx2)) } None => error(UnterminatedCode, idx0), } } fn code(&mut self, idx0: usize, open_delims: &str, close_delims: &str) -> Result { // This is the interesting case. To find the end of the code, // we have to scan ahead, matching (), [], and {}, and looking // for a suitable terminator: `,`, `;`, `]`, `}`, or `)`. // Additionaly we had to take into account that we can encounter an character literal // equal to one of delimiters. let mut balance = 0; // number of unclosed `(` etc loop { if let Some((idx, c)) = self.lookahead { if c == '"' { self.bump(); self.string_literal(idx)?; // discard the produced token continue; } else if c == '\'' { self.bump(); if self.take_lifetime_or_character_literal().is_none() { return error(UnterminatedCharacterLiteral, idx); } continue; } else if c == 'r' { self.bump(); if let Some((idx, '#')) = self.lookahead { self.regex_literal(idx)?; } continue; } else if c == '/' { self.bump(); if let Some((_, '/')) = self.lookahead { self.take_until(|c| c == '\n'); } continue; } else if open_delims.find(c).is_some() { balance += 1; } else if balance > 0 { if close_delims.find(c).is_some() { balance -= 1; } } else { debug_assert!(balance == 0); if c == ',' || c == ';' || close_delims.find(c).is_some() { // Note: we do not consume the // terminator. The code is everything *up // to but not including* the terminating // `,`, `;`, etc. return Ok(idx); } } } else if balance > 0 { // the input should not end with an // unbalanced number of `{` etc! return error(UnterminatedCode, idx0); } else { debug_assert!(balance == 0); return Ok(self.text.len()); } self.bump(); } } fn escape(&mut self, idx0: usize) -> Result>, Error> { match self.take_until(|c| c == '`') { Some(idx1) => { self.bump(); // consume the '`' let text: &'input str = &self.text[idx0 + 1..idx1]; // do not include the `` in the str Ok((idx0, Escape(text), idx1 + 1)) } None => error(UnterminatedEscape, idx0), } } fn take_lifetime_or_character_literal(&mut self) -> Option { // Try to decide whether `'` is the start of a lifetime or a character literal. let forget_character = |p: (usize, char)| p.0; self.lookahead.and_then(|(_, c)| { if c == '\\' { // escape after `'` => it had to be character literal token, consume // the backslash and escaped character, then consume until `'` self.bump(); self.bump(); self.take_until_and_consume_terminating_character(|c: char| c == '\'') } else { // no escape, then we require to see next `'` or we assume it was lifetime self.bump().and_then(|(idx, c)| { if c == '\'' { self.bump().map(forget_character) } else { Some(idx) } }) } }) } fn string_or_char_literal( &mut self, idx0: usize, quote: char, variant: fn(&'input str) -> Tok<'input>, ) -> Option>> { let mut escape = false; let terminate = |c: char| { if escape { escape = false; false } else if c == '\\' { escape = true; false } else { c == quote } }; match self.take_until(terminate) { Some(idx1) => { self.bump(); // consume the closing quote let text = &self.text[idx0 + 1..idx1]; // do not include quotes in the str Some((idx0, variant(text), idx1 + 1)) } None => None, } } fn string_literal(&mut self, idx0: usize) -> Result>, Error> { match self.string_or_char_literal(idx0, '"', StringLiteral) { Some(x) => Ok(x), None => error(UnterminatedStringLiteral, idx0), } } // parses `r#"..."#` (for some number of #), starts after the `r` // has been consumed; idx0 points at the `r` fn regex_literal(&mut self, idx0: usize) -> Result>, Error> { match self.take_while(|c| c == '#') { Some(idx1) if self.lookahead == Some((idx1, '"')) => { self.bump(); let hashes = idx1 - idx0 - 1; let mut state = 0; let end_of_regex = |c: char| { if state > 0 { // state N>0 means: observed n-1 hashes if c == '#' { state += 1; } else { state = 0; } } // state 0 means: not yet seen the `"` if state == 0 && c == '"' { state = 1; } state == (hashes + 1) }; match self.take_until(end_of_regex) { Some(idx1) => { // idx1 is the closing quote self.bump(); let start = idx0 + 2 + hashes; // skip the `r###"` let end = idx1 - hashes; // skip the `###`. Ok((idx0, RegexLiteral(&self.text[start..end]), idx1 + 1)) } None => error(UnterminatedStringLiteral, idx0), } } Some(idx1) => error(ExpectedStringLiteral, idx1), None => error(UnterminatedStringLiteral, idx0), } } // Saw a `'`, could either be: `'a` or `'a'`. fn lifetimeish(&mut self, idx0: usize) -> Result>, Error> { match self.lookahead { None => error(UnterminatedCharacterLiteral, idx0), Some((_, c)) => { if is_identifier_start(c) { let (start, word, end) = self.word(idx0); match self.lookahead { Some((idx2, '\'')) => { self.bump(); let text = &self.text[idx0 + 1..idx2]; Ok((idx0, CharLiteral(text), idx2 + 1)) } _ => Ok((start, Lifetime(word), end)), } } else { match self.string_or_char_literal(idx0, '\'', CharLiteral) { Some(x) => Ok(x), None => error(UnterminatedCharacterLiteral, idx0), } } } } } fn identifierish(&mut self, idx0: usize) -> Result>, Error> { let (start, word, end) = self.word(idx0); if word == "_" { return Ok((idx0, Underscore, idx0 + 1)); } if word == "use" { let code_end = self.code(idx0, "([{", "}])")?; let code = &self.text[end..code_end]; return Ok((start, Tok::Use(code), code_end)); } let tok = // search for a keyword first; if none are found, this is // either a MacroId or an Id, depending on whether there // is a `<` immediately afterwards KEYWORDS.iter() .filter(|&&(w, _)| w == word) .map(|&(_, ref t)| t.clone()) .next() .unwrap_or_else(|| { match self.lookahead { Some((_, '<')) => MacroId(word), _ => Id(word), } }); Ok((start, tok, end)) } fn word(&mut self, idx0: usize) -> Spanned<&'input str> { match self.take_while(is_identifier_continue) { Some(end) => (idx0, &self.text[idx0..end], end), None => (idx0, &self.text[idx0..], self.text.len()), } } fn take_while(&mut self, mut keep_going: F) -> Option where F: FnMut(char) -> bool, { self.take_until(|c| !keep_going(c)) } fn take_until(&mut self, mut terminate: F) -> Option where F: FnMut(char) -> bool, { loop { match self.lookahead { None => { return None; } Some((idx1, c)) => { if terminate(c) { return Some(idx1); } else { self.bump(); } } } } } fn take_until_and_consume_terminating_character(&mut self, terminate: F) -> Option where F: FnMut(char) -> bool, { self.take_until(terminate) .and_then(|_| self.bump().map(|p| p.0)) } fn expect_char(&mut self, c: char) -> Option> { match self.lookahead { Some((idx0, cc)) if c == cc => { self.bump(); Some(Ok(idx0)) } Some((idx0, _)) => { self.bump(); Some(error(UnrecognizedToken, idx0)) } None => None, } } } impl<'input> Iterator for Tokenizer<'input> { type Item = Result>, Error>; fn next(&mut self) -> Option>, Error>> { match self.next_unshifted() { None => None, Some(Ok((l, t, r))) => Some(Ok((l + self.shift, t, r + self.shift))), Some(Err(Error { location, code })) => Some(Err(Error { location: location + self.shift, code, })), } } } fn is_identifier_start(c: char) -> bool { UnicodeXID::is_xid_start(c) || c == '_' } fn is_identifier_continue(c: char) -> bool { UnicodeXID::is_xid_continue(c) || c == '_' } /// Expand escape characters in a string literal, converting the source code /// representation to the text it represents. The `idx0` argument should be the /// position in the input stream of the first character of `text`, the position /// after the opening double-quote. pub fn apply_string_escapes(code: &str, idx0: usize) -> Result, Error> { if !code.contains('\\') { Ok(code.into()) } else { let mut iter = code.char_indices(); let mut text = String::new(); while let Some((_, mut ch)) = iter.next() { if ch == '\\' { // The parser should never have accepted an ill-formed string // literal, so we know it can't end in a backslash. let (offset, next_ch) = iter.next().unwrap(); ch = match next_ch { '\\' | '\"' => next_ch, 'n' => '\n', 'r' => '\r', 't' => '\t', _ => { return error(UnrecognizedEscape, idx0 + offset); } } } text.push(ch); } Ok(text.into()) } } lalrpop-0.17.2/src/tok/test.rs000064400000000000000000000477151346225060300143700ustar0000000000000000use super::Tok::*; use super::{Error, ErrorCode, Tok, Tokenizer}; enum Expectation<'a> { ExpectTok(Tok<'a>), ExpectErr(ErrorCode), } use self::Expectation::*; fn gen_test(input: &str, expected: Vec<(&str, Expectation)>) { // use $ to signal EOL because it can be replaced with a single space // for spans, and because it applies also to r#XXX# style strings: let input = input.replace("$", "\n"); let tokenizer = Tokenizer::new(&input, 0); let len = expected.len(); for (token, (expected_span, expectation)) in tokenizer.zip(expected.into_iter()) { let expected_start = expected_span.find("~").unwrap(); let expected_end = expected_span.rfind("~").unwrap() + 1; println!("token: {:?}", token); match expectation { ExpectTok(expected_tok) => { assert_eq!(Ok((expected_start, expected_tok, expected_end)), token); } ExpectErr(expected_ec) => assert_eq!( Err(Error { location: expected_start, code: expected_ec, }), token ), } } let tokenizer = Tokenizer::new(&input, 0); assert_eq!(None, tokenizer.skip(len).next()); } fn test(input: &str, expected: Vec<(&str, Tok)>) { let generic_expected = expected .into_iter() .map(|(span, tok)| (span, ExpectTok(tok))) .collect(); gen_test(input, generic_expected); } fn test_err(input: &str, expected: (&str, ErrorCode)) { let (span, ec) = expected; gen_test(input, vec![(span, ExpectErr(ec))]) } #[test] fn basic() { test( "extern foo", vec![("~~~~~~ ", Extern), (" ~~~", Id("foo"))], ); } #[test] fn eol_comment() { test( "extern // This is a comment$ foo", vec![ ("~~~~~~ ", Extern), (" ~~~", Id("foo")), ], ); } #[test] fn code1() { test( "=> a(b, c),", vec![ ("~~~~~~~~~~ ", EqualsGreaterThanCode(" a(b, c)")), (" ~", Comma), ], ); } #[test] fn rule_id_then_equalsgreaterthancode_functioncall() { test( "id => a(b, c),", vec![ ("~~ ", Id("id")), (" ~~~~~~~~~~ ", EqualsGreaterThanCode(" a(b, c)")), (" ~", Comma), ], ); } #[test] fn rule_stringliteral_slash_dot_then_equalsgreaterthancode_functioncall() { test( r#" "\." => a(b, c),"#, vec![ (r#" ~~~~ "#, StringLiteral(r#"\."#)), (r#" ~~~~~~~~~~ "#, EqualsGreaterThanCode(" a(b, c)")), (r#" ~"#, Comma), ], ); } #[test] fn rule_stringliteral_slash_dot_then_equalsgreaterthancode_many_characters_in_stringliteral() { test( r#" "\." => "Planet Earth" ,"#, vec![ (r#" ~~~~ "#, StringLiteral(r#"\."#)), ( r#" ~~~~~~~~~~~~~~~~~~ "#, EqualsGreaterThanCode(r#" "Planet Earth" "#), ), (r#" ~"#, Comma), ], ); } #[test] fn rule_stringliteral_slash_dot_then_equalsgreaterthancode_one_character_dot_in_stringliteral() { test( r#" "\." => "." ,"#, vec![ (r#" ~~~~ "#, StringLiteral(r#"\."#)), (r#" ~~~~~~~ "#, EqualsGreaterThanCode(r#" "." "#)), (r#" ~"#, Comma), ], ); } #[test] fn rule_stringliteral_slash_openningbracket_then_equalsgreaterthancode_one_character_openningbracket_in_stringliteral( ) { test( r#" "\(" => "(" ,"#, vec![ (r#" ~~~~ "#, StringLiteral(r#"\("#)), (r#" ~~~~~~~ "#, EqualsGreaterThanCode(r#" "(" "#)), (r#" ~"#, Comma), ], ); } #[test] fn rule_stringliteral_slash_openningbracket_then_equalsgreaterthancode_empty_stringliteral() { test( r#" "\(" => "" ,"#, vec![ (r#" ~~~~ "#, StringLiteral(r#"\("#)), (r#" ~~~~~~ "#, EqualsGreaterThanCode(r#" "" "#)), (r#" ~"#, Comma), ], ); } #[test] fn rule_stringliteral_slash_dot_then_equalsgreaterthancode_one_character_dot() { test( r#" "\." => '.' ,"#, vec![ (r#" ~~~~ "#, StringLiteral(r#"\."#)), (r#" ~~~~~~~ "#, EqualsGreaterThanCode(r#" '.' "#)), (r#" ~"#, Comma), ], ); } #[test] fn rule_stringliteral_slash_openningbracket_then_equalsgreaterthancode_one_character_openningbracket( ) { test( r#" "\(" => '(' ,"#, vec![ (r#" ~~~~ "#, StringLiteral(r#"\("#)), (r#" ~~~~~~~ "#, EqualsGreaterThanCode(r#" '(' "#)), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_one_character_openningbracket() { test( r#"=> '(' ,"#, vec![ (r#"~~~~~~~ "#, EqualsGreaterThanCode(r#" '(' "#)), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_one_character_escaped_n() { test( r#"=> '\n' ,"#, vec![ (r#"~~~~~~~~ "#, EqualsGreaterThanCode(r#" '\n' "#)), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_one_character_escaped_w() { test( r#"=> '\w' ,"#, vec![ (r#"~~~~~~~~ "#, EqualsGreaterThanCode(r#" '\w' "#)), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_one_character_escaped_planet123() { test( r#"=> '\planet123' ,"#, vec![ ( r#"~~~~~~~~~~~~~~~~ "#, EqualsGreaterThanCode(r#" '\planet123' "#), ), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_one_character_openningcurlybracket() { test( r#"=> '{' ,"#, vec![ (r#"~~~~~~~ "#, EqualsGreaterThanCode(r#" '{' "#)), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_one_character_openningsquarebracket() { test( r#"=> '[' ,"#, vec![ (r#"~~~~~~~ "#, EqualsGreaterThanCode(r#" '[' "#)), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_one_character_openningbracket_wrapped_by_brackets() { test( r#"=> ('(') ,"#, vec![ (r#"~~~~~~~~~ "#, EqualsGreaterThanCode(r#" ('(') "#)), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_one_character_closingbracket_wrapped_by_brackets() { test( r#"=> (')') ,"#, vec![ (r#"~~~~~~~~~ "#, EqualsGreaterThanCode(r#" (')') "#)), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_tuple() { test( r#"=> (1,2,3) ,"#, vec![ (r#"~~~~~~~~~~~ "#, EqualsGreaterThanCode(r#" (1,2,3) "#)), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_statement_with_lifetime() { test( r#"=> HuffmanTable::>::new() ,"#, vec![ ( r#"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ "#, EqualsGreaterThanCode(r#" HuffmanTable::>::new() "#), ), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_statement_with_many_lifetimes() { test( r#"=> (HuffmanTable::>::new()),"#, vec![ ( r#"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ "#, EqualsGreaterThanCode(r#" (HuffmanTable::>::new())"#), ), (r#" ~"#, Comma), ], ); } #[test] fn equalsgreaterthancode_nested_function_with_lifetimes() { test( r#"=> fn foo<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {} ,"#, vec![ ( r#"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ "#, EqualsGreaterThanCode(r#" fn foo<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {} "#), ), ( r#" ~"#, Comma, ), ], ); } #[test] fn where_with_lifetimes() { test( r#"where <'a,bar<'b,'c>>,baz;"#, vec![ (r#"~~~~~ "#, Where), (r#" ~ "#, LessThan), (r#" ~~ "#, Lifetime("'a")), (r#" ~ "#, Comma), (r#" ~~~ "#, MacroId("bar")), (r#" ~ "#, LessThan), (r#" ~~ "#, Lifetime("'b")), (r#" ~ "#, Comma), (r#" ~~ "#, Lifetime("'c")), (r#" ~ "#, GreaterThan), (r#" ~ "#, GreaterThan), (r#" ~ "#, Comma), (r#" ~~~ "#, Id("baz")), (r#" ~"#, Semi), ], ); } #[test] fn forall() { test( r#"for<'a, 'b, 'c> FnMut"#, vec![ (r#"~~~ "#, For), (r#" ~ "#, LessThan), (r#" ~~ "#, Lifetime("'a")), (r#" ~ "#, Comma), (r#" ~~ "#, Lifetime("'b")), (r#" ~ "#, Comma), (r#" ~~ "#, Lifetime("'c")), (r#" ~ "#, GreaterThan), (r#" ~~~~~"#, Id("FnMut")), ], ); } #[test] fn where_forall_fnmut_with_return_type() { test( r#"where F: for<'a> FnMut(&'a T) -> U;"#, vec![ (r#"~~~~~ "#, Where), (r#" ~ "#, Id("F")), (r#" ~ "#, Colon), (r#" ~~~ "#, For), (r#" ~ "#, LessThan), (r#" ~~ "#, Lifetime("'a")), (r#" ~ "#, GreaterThan), (r#" ~~~~~ "#, Id("FnMut")), (r#" ~ "#, LeftParen), (r#" ~ "#, Ampersand), (r#" ~~ "#, Lifetime("'a")), (r#" ~ "#, Id("T")), (r#" ~ "#, RightParen), (r#" ~~ "#, MinusGreaterThan), (r#" ~ "#, Id("U")), (r#" ~"#, Semi), ], ); } #[test] fn equalsgreaterthancode_error_unbalanced() { test_err(r#"=> (,"#, (r#"~ "#, ErrorCode::UnterminatedCode)) } #[test] fn equalsgreaterthancode_error_unbalanced_closingbracket_character() { test_err( r#"=> (,')',"#, (r#"~ "#, ErrorCode::UnterminatedCode), ) } #[test] fn equalsgreaterthancode_error_unterminated_string_literal() { test_err( r#"=> "Jan III Sobieski"#, ( r#" ~ "#, ErrorCode::UnterminatedStringLiteral, ), ) } #[test] fn equalsgreaterthancode_error_unterminated_character_literal() { test_err( r#"=> '\x233 "#, (r#" ~ "#, ErrorCode::UnterminatedCharacterLiteral), ) } #[test] fn equalsgreaterthancode_error_end_of_input_instead_of_closing_normal_character_literal() { test_err( r#"=> 'x"#, (r#" ~ "#, ErrorCode::UnterminatedCharacterLiteral), ) } #[test] fn equalsgreaterthancode_single_quote_literal() { test( r#"=> { println!('\''); },"#, vec![ ( r#"~~~~~~~~~~~~~~~~~~~~~~ "#, EqualsGreaterThanCode(r#" { println!('\''); }"#), ), (r#" ~"#, Comma), ], ); } #[test] fn code_paren() { // Issue #25 test( r#"=> a("(", c),"#, vec![ (r#"~~~~~~~~~~~~ "#, EqualsGreaterThanCode(r#" a("(", c)"#)), (r#" ~"#, Comma), ], ); } #[test] fn code_regex_paren() { // Issue #25 test( r###"=> a(r##"("#""##, c),"###, vec![ ( r###"~~~~~~~~~~~~~~~~~~~~ "###, EqualsGreaterThanCode(r###" a(r##"("#""##, c)"###), ), (r###" ~"###, Comma), ], ); } #[test] fn code_comment_eol() { test( "=> a(// ( ),", vec![ ( "~~~~~~~~~ ~,", EqualsGreaterThanCode(" a(// (\n)"), ), ( "=> a(// ( )~", Comma, ), ], ); } #[test] fn code2() { test( "=>? a(b, c),", vec![ ("~~~~~~~~~~~ ", EqualsGreaterThanQuestionCode(" a(b, c)")), (" ~", Comma), ], ); } #[test] #[should_panic] fn code_forgot_comma() { test( "=> a(b, c),", vec![ ("~~~~~~~~~~ ", EqualsGreaterThanCode(" a(b, c)")), // intentionally forget the comma token; this is more of a test of `test` ], ); } #[test] fn various_kinds_of_ids() { test( "foo>", vec![ ("~~~ ", MacroId("foo")), (" ~ ", LessThan), (" ~ ", MacroId("T")), (" ~ ", LessThan), (" ~~ ", Lifetime("'a")), (" ~ ", Comma), (" ~ ", Id("U")), (" ~ ", Comma), (" ~~~~~~ ", Escape("Z*{}")), (" ~ ", GreaterThan), (" ~", GreaterThan), ], ); } #[test] fn string_literals() { test( r#"foo "bar\"\n" baz"#, vec![ (r#"~~~ "#, Id("foo")), (r#" ~~~~~~~~~ "#, StringLiteral(r#"bar\"\n"#)), (r#" ~~~"#, Id("baz")), ], ); } #[test] fn use1() { test( r#"use foo::bar; baz"#, vec![ (r#"~~~~~~~~~~~~ "#, Use(" foo::bar")), (r#" ~ "#, Semi), (r#" ~~~"#, Id("baz")), ], ); } #[test] fn use2() { test( r#"use {foo,bar}; baz"#, vec![ (r#"~~~~~~~~~~~~~ "#, Use(" {foo,bar}")), (r#" ~ "#, Semi), (r#" ~~~"#, Id("baz")), ], ); } #[test] fn where1() { test( r#"where ,baz;"#, vec![ (r#"~~~~~ "#, Where), (r#" ~ "#, LessThan), (r#" ~~~ "#, Id("foo")), (r#" ~ "#, Comma), (r#" ~~~ "#, Id("bar")), (r#" ~ "#, GreaterThan), (r#" ~ "#, Comma), (r#" ~~~ "#, Id("baz")), (r#" ~"#, Semi), ], ); } #[test] fn regex1() { test( r#####"raa r##" #"#"" "#"##rrr"#####, vec![ (r#####"~~~ "#####, Id("raa")), ( r#####" ~~~~~~~~~~~~~~~~ "#####, RegexLiteral(r##" #"#"" "#"##), ), (r#####" ~~~"#####, Id("rrr")), ], ); } #[test] fn hash_token() { test(r#" # "#, vec![(r#" ~ "#, Hash)]); } #[test] fn shebang_attribute_normal_text() { test( r#" #![Attribute] "#, vec![(r#" ~~~~~~~~~~~~~ "#, ShebangAttribute("#![Attribute]"))], ); } #[test] fn shebang_attribute_special_characters_without_quotes() { test( r#" #![set width = 80] "#, vec![( r#" ~~~~~~~~~~~~~~~~~~ "#, ShebangAttribute("#![set width = 80]"), )], ); } #[test] fn shebang_attribute_special_characters_with_quotes() { test( r#" #![set width = "80"] "#, vec![( r#" ~~~~~~~~~~~~~~~~~~~~ "#, ShebangAttribute(r#"#![set width = "80"]"#), )], ); } #[test] fn shebang_attribute_special_characters_closing_sqbracket_in_string_literal() { test( r#" #![set width = "80]"] "#, vec![( r#" ~~~~~~~~~~~~~~~~~~~~~ "#, ShebangAttribute(r#"#![set width = "80]"]"#), )], ); } #[test] fn shebang_attribute_special_characters_opening_sqbracket_in_string_literal() { test( r#" #![set width = "[80"] "#, vec![( r#" ~~~~~~~~~~~~~~~~~~~~~ "#, ShebangAttribute(r#"#![set width = "[80"]"#), )], ); } #[test] fn shebang_attribute_special_characters_nested_sqbrackets() { test( r#" #![set width = [80]] "#, vec![( r#" ~~~~~~~~~~~~~~~~~~~~ "#, ShebangAttribute(r#"#![set width = [80]]"#), )], ); } #[test] fn regex2() { test(r#"r"(123""#, vec![(r#"~~~~~~~"#, RegexLiteral(r"(123"))]); } #[test] fn char_literals() { test( r#"'foo' 'a 'b '!' '!!' '\'' 'c"#, vec![ (r#"~~~~~ "#, CharLiteral("foo")), (r#" ~~ "#, Lifetime("'a")), (r#" ~~ "#, Lifetime("'b")), (r#" ~~~ "#, CharLiteral("!")), (r#" ~~~~ "#, CharLiteral("!!")), (r#" ~~~~ "#, CharLiteral("\\'")), (r#" ~~"#, Lifetime("'c")), ], ); } #[test] fn string_escapes() { use super::apply_string_escapes; use std::borrow::Cow; assert_eq!(apply_string_escapes(r#"foo"#, 5), Ok(Cow::Borrowed("foo"))); assert_eq!( apply_string_escapes(r#"\\"#, 10), Ok(Cow::Owned::(r#"\"#.into())) ); assert_eq!( apply_string_escapes(r#"\""#, 15), Ok(Cow::Owned::(r#"""#.into())) ); assert_eq!( apply_string_escapes(r#"up\ndown"#, 25), Ok(Cow::Owned::("up\ndown".into())) ); assert_eq!( apply_string_escapes(r#"forth\rback"#, 25), Ok(Cow::Owned::("forth\rback".into())) ); assert_eq!( apply_string_escapes(r#"left\tright"#, 40), Ok(Cow::Owned::("left\tright".into())) ); // Errors. assert_eq!( apply_string_escapes("\u{192}\\oo", 65), // "ƒ\oo" Err(Error { location: 68, code: ErrorCode::UnrecognizedEscape }) ); // LALRPOP doesn't support the other Rust escape sequences. assert_eq!( apply_string_escapes(r#"star: \u{2a}"#, 105), Err(Error { location: 112, code: ErrorCode::UnrecognizedEscape }) ); } lalrpop-0.17.2/src/util.rs000064400000000000000000000026661350346013400135630ustar0000000000000000use std::fmt::{Display, Error, Formatter}; pub use std::collections::btree_map as map; pub struct Sep(pub &'static str, pub S); impl<'a, S: Display> Display for Sep<&'a Vec> { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { let &Sep(sep, vec) = self; let mut elems = vec.iter(); if let Some(elem) = elems.next() { write!(fmt, "{}", elem)?; for elem in elems { write!(fmt, "{}{}", sep, elem)?; } } Ok(()) } } pub struct Escape(pub S); impl Display for Escape { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { let tmp = format!("{}", self.0); for c in tmp.chars() { match c { 'a'..='z' | '0'..='9' | 'A'..='Z' => write!(fmt, "{}", c)?, '_' => write!(fmt, "__")?, _ => write!(fmt, "_{:x}", c as usize)?, } } Ok(()) } } pub struct Prefix(pub &'static str, pub S); impl<'a, S: Display> Display for Prefix<&'a [S]> { fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> { let &Prefix(prefix, vec) = self; for elem in vec.iter() { write!(fmt, "{}{}", prefix, elem)?; } Ok(()) } } /// Strip leading and trailing whitespace. pub fn strip(s: &str) -> &str { s.trim_matches(char::is_whitespace) } lalrpop-0.17.2/.cargo_vcs_info.json0000644000000001120000000000000126250ustar00{ "git": { "sha1": "7eb9261e1cffa3ecf1a165147265787fb273c61d" } } lalrpop-0.17.2/Cargo.lock0000644000001060600000000000000106110ustar00# This file is automatically @generated by Cargo. # It is not intended for manual editing. [[package]] name = "aho-corasick" version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "arrayref" version = "0.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "arrayvec" version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "ascii-canvas" version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "term 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "atty" version = "0.2.13" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "autocfg" version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "backtrace" version = "0.3.35" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "backtrace-sys 0.1.31 (registry+https://github.com/rust-lang/crates.io-index)", "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "backtrace-sys" version = "0.1.31" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "base64" version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "bit-set" version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "bit-vec 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "bit-vec" version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "bitflags" version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "blake2b_simd" version = "0.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)", "arrayvec 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)", "constant_time_eq 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "block-buffer" version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "block-padding 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)", "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", "generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "block-padding" version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "byte-tools" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "byteorder" version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "cc" version = "1.0.40" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "cfg-if" version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "cloudabi" version = "0.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "constant_time_eq" version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "crossbeam-utils" version = "0.6.6" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "diff" version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "digest" version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "dirs" version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "redox_users 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "docopt" version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", "strsim 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "either" version = "1.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "ena" version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "failure" version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "backtrace 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)", "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "failure_derive" version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)", "synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "fake-simd" version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "fixedbitset" version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "fuchsia-cprng" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "generic-array" version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "itertools" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "lalrpop" version = "0.17.2" dependencies = [ "ascii-canvas 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "atty 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)", "bit-set 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", "diff 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)", "docopt 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "ena 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)", "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", "lalrpop-util 0.17.2 (registry+https://github.com/rust-lang/crates.io-index)", "petgraph 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "regex-syntax 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", "serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", "sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", "string_cache 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)", "term 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "lalrpop-util" version = "0.17.2" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "lazy_static" version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "libc" version = "0.2.62" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "log" version = "0.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "memchr" version = "2.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "new_debug_unreachable" version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "nodrop" version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "opaque-debug" version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "ordermap" version = "0.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "petgraph" version = "0.4.13" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "fixedbitset 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", "ordermap 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "phf_generator" version = "0.7.24" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "phf_shared" version = "0.7.24" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "siphasher 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "precomputed-hash" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "proc-macro2" version = "0.4.30" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "proc-macro2" version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "quote" version = "0.6.13" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "quote" version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand" version = "0.6.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "autocfg 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", "rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "rand_jitter 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)", "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", "rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand_chacha" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "autocfg 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand_core" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand_core" version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "rand_hc" version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand_isaac" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand_jitter" version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand_os" version = "0.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)", "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand_pcg" version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "autocfg 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand_xorshift" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rdrand" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "redox_syscall" version = "0.1.56" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "redox_users" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", "redox_syscall 0.1.56 (registry+https://github.com/rust-lang/crates.io-index)", "rust-argon2 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "regex" version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "aho-corasick 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)", "memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "regex-syntax 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)", "thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "regex-syntax" version = "0.6.11" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "rust-argon2" version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)", "blake2b_simd 0.5.7 (registry+https://github.com/rust-lang/crates.io-index)", "crossbeam-utils 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rustc-demangle" version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "serde" version = "1.0.99" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "serde_derive" version = "1.0.99" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", "syn 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "sha2" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)", "digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)", "fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", "opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "siphasher" version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "string_cache" version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", "new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)", "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", "precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", "string_cache_codegen 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", "string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "string_cache_codegen" version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", "phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)", "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", "string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "string_cache_shared" version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "strsim" version = "0.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "syn" version = "0.15.44" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "syn" version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "synstructure" version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)", "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "term" version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", "dirs 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "thread_local" version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "typenum" version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "unicode-xid" version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "unicode-xid" version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "winapi" version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "winapi-i686-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "winapi-x86_64-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" [metadata] "checksum aho-corasick 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "58fb5e95d83b38284460a5fda7d6470aa0b8844d283a0b614b8535e880800d2d" "checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee" "checksum arrayvec 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b8d73f9beda665eaa98ab9e4f7442bd4e7de6652587de55b2525e52e29c1b0ba" "checksum ascii-canvas 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ff8eb72df928aafb99fe5d37b383f2fe25bd2a765e3e5f7c365916b6f2463a29" "checksum atty 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1803c647a3ec87095e7ae7acfca019e98de5ec9a7d01343f611cf3152ed71a90" "checksum autocfg 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "b671c8fb71b457dd4ae18c4ba1e59aa81793daacc361d82fcd410cef0d491875" "checksum backtrace 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)" = "1371048253fa3bac6704bfd6bbfc922ee9bdcee8881330d40f308b81cc5adc55" "checksum backtrace-sys 0.1.31 (registry+https://github.com/rust-lang/crates.io-index)" = "82a830b4ef2d1124a711c71d263c5abdc710ef8e907bd508c88be475cebc422b" "checksum base64 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e" "checksum bit-set 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e84c238982c4b1e1ee668d136c510c67a13465279c0cb367ea6baf6310620a80" "checksum bit-vec 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f59bbe95d4e52a6398ec21238d31577f2b28a9d86807f06ca59d191d8440d0bb" "checksum bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3d155346769a6855b86399e9bc3814ab343cd3d62c7e985113d46a0ec3c281fd" "checksum blake2b_simd 0.5.7 (registry+https://github.com/rust-lang/crates.io-index)" = "bf775a81bb2d464e20ff170ac20316c7b08a43d11dbc72f0f82e8e8d3d6d0499" "checksum block-buffer 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b" "checksum block-padding 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "6d4dc3af3ee2e12f3e5d224e5e1e3d73668abbeb69e566d361f7d5563a4fdf09" "checksum byte-tools 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7" "checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5" "checksum cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)" = "b548a4ee81fccb95919d4e22cfea83c7693ebfd78f0495493178db20b3139da7" "checksum cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "b486ce3ccf7ffd79fdeb678eac06a9e6c09fc88d33836340becb8fffe87c5e33" "checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f" "checksum constant_time_eq 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "995a44c877f9212528ccc74b21a232f66ad69001e40ede5bcee2ac9ef2657120" "checksum crossbeam-utils 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "04973fa96e96579258a5091af6003abde64af786b860f18622b82e026cca60e6" "checksum diff 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "3c2b69f912779fbb121ceb775d74d51e915af17aaebc38d28a592843a2dd0a3a" "checksum digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5" "checksum dirs 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "3fd78930633bd1c6e35c4b42b1df7b0cbc6bc191146e512bb3bedf243fcc3901" "checksum docopt 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7f525a586d310c87df72ebcd98009e57f1cc030c8c268305287a476beb653969" "checksum either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "5527cfe0d098f36e3f8839852688e63c8fff1c90b2b405aef730615f9a7bcf7b" "checksum ena 0.13.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3dc01d68e08ca384955a3aeba9217102ca1aa85b6e168639bf27739f1d749d87" "checksum failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "795bd83d3abeb9220f257e597aa0080a508b27533824adf336529648f6abf7e2" "checksum failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "ea1063915fd7ef4309e222a5a07cf9c319fb9c7836b1f89b85458672dbb127e1" "checksum fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed" "checksum fixedbitset 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "86d4de0081402f5e88cdac65c8dcdcc73118c1a7a465e2a05f0da05843a8ea33" "checksum fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba" "checksum generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec" "checksum itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5b8467d9c1cebe26feb08c640139247fac215782d35371ade9a2136ed6085358" "checksum lalrpop-util 0.17.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c277d18683b36349ab5cd030158b54856fca6bb2d5dc5263b06288f486958b7c" "checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14" "checksum libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)" = "34fcd2c08d2f832f376f4173a231990fa5aef4e99fb569867318a227ef4c06ba" "checksum log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7" "checksum memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88579771288728879b57485cc7d6b07d648c9f0141eb955f8ab7f9d45394468e" "checksum new_debug_unreachable 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f40f005c60db6e03bae699e414c58bf9aa7ea02a2d0b9bfbcf19286cc4c82b30" "checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945" "checksum opaque-debug 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c" "checksum ordermap 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "a86ed3f5f244b372d6b1a00b72ef7f8876d0bc6a78a4c9985c53614041512063" "checksum petgraph 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)" = "9c3659d1ee90221741f65dd128d9998311b0e40c5d3c23a62445938214abce4f" "checksum phf_generator 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "09364cc93c159b8b06b1f4dd8a4398984503483891b0c26b867cf431fb132662" "checksum phf_shared 0.7.24 (registry+https://github.com/rust-lang/crates.io-index)" = "234f71a15de2288bcb7e3b6515828d22af7ec8598ee6d24c3b526fa0a80b67a0" "checksum precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" "checksum proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)" = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759" "checksum proc-macro2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4c5c2380ae88876faae57698be9e9775e3544decad214599c3a6266cca6ac802" "checksum quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)" = "6ce23b6b870e8f94f81fb0a363d65d86675884b34a09043c81e5562f11c1f8e1" "checksum quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "053a8c8bcc71fcce321828dc897a98ab9760bef03a4fc36693c231e5b3216cfe" "checksum rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca" "checksum rand_chacha 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef" "checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b" "checksum rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc" "checksum rand_hc 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b40677c7be09ae76218dc623efbf7b18e34bced3f38883af07bb75630a21bc4" "checksum rand_isaac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ded997c9d5f13925be2a6fd7e66bf1872597f759fd9dd93513dd7e92e5a5ee08" "checksum rand_jitter 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b" "checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071" "checksum rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44" "checksum rand_xorshift 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c" "checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2" "checksum redox_syscall 0.1.56 (registry+https://github.com/rust-lang/crates.io-index)" = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84" "checksum redox_users 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4ecedbca3bf205f8d8f5c2b44d83cd0690e39ee84b951ed649e9f1841132b66d" "checksum regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88c3d9193984285d544df4a30c23a4e62ead42edf70a4452ceb76dac1ce05c26" "checksum regex-syntax 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b143cceb2ca5e56d5671988ef8b15615733e7ee16cd348e064333b251b89343f" "checksum rust-argon2 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4ca4eaef519b494d1f2848fc602d18816fed808a981aedf4f1f00ceb7c9d32cf" "checksum rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783" "checksum serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)" = "fec2851eb56d010dc9a21b89ca53ee75e6528bab60c11e89d38390904982da9f" "checksum serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)" = "cb4dc18c61206b08dc98216c98faa0232f4337e1e1b8574551d5bad29ea1b425" "checksum sha2 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7b4d8bfd0e469f417657573d8451fb33d16cfe0989359b93baf3a1ffc639543d" "checksum siphasher 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0b8de496cf83d4ed58b6be86c3a275b8602f6ffe98d3024a869e124147a9a3ac" "checksum string_cache 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "25d70109977172b127fe834e5449e5ab1740b9ba49fa18a2020f509174f25423" "checksum string_cache_codegen 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1eea1eee654ef80933142157fdad9dd8bc43cf7c74e999e369263496f04ff4da" "checksum string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b1884d1bc09741d466d9b14e6d37ac89d6909cbcac41dd9ae982d4d063bbedfc" "checksum strsim 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)" = "032c03039aae92b350aad2e3779c352e104d919cb192ba2fabbd7b831ce4f0f6" "checksum syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)" = "9ca4b3b69a77cbe1ffc9e198781b7acb0c7365a883670e8f1c1bc66fba79a5c5" "checksum syn 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "158521e6f544e7e3dcfc370ac180794aa38cb34a1b1e07609376d4adcf429b93" "checksum synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "02353edf96d6e4dc81aea2d8490a7e9db177bf8acb0e951c24940bf866cb313f" "checksum term 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "edd106a334b7657c10b7c540a0106114feadeb4dc314513e97df481d5d966f42" "checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b" "checksum typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "612d636f949607bdf9b123b4a6f6d966dedf3ff669f7f045890d3a4a73948169" "checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc" "checksum unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c" "checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770" "checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" "checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"