From ce41b2872961b9f8d3f53b5852e84ab2d8f5fa5a Mon Sep 17 00:00:00 2001 From: dalance Date: Thu, 18 Apr 2024 16:40:46 +0900 Subject: [PATCH] Add generics support --- crates/analyzer/src/analyzer.rs | 26 +- crates/analyzer/src/analyzer_error.rs | 45 +- .../analyzer/src/handlers/check_function.rs | 5 +- .../analyzer/src/handlers/check_instance.rs | 1 + crates/analyzer/src/handlers/check_msb_lsb.rs | 3 +- .../analyzer/src/handlers/create_reference.rs | 100 +- .../src/handlers/create_symbol_table.rs | 209 +- .../analyzer/src/handlers/create_type_dag.rs | 7 +- crates/analyzer/src/lib.rs | 1 + crates/analyzer/src/namespace.rs | 15 +- crates/analyzer/src/symbol.rs | 157 +- crates/analyzer/src/symbol_path.rs | 434 + crates/analyzer/src/symbol_table.rs | 215 +- crates/analyzer/src/tests.rs | 42 +- crates/analyzer/src/type_dag.rs | 7 +- crates/emitter/src/aligner.rs | 7 +- crates/emitter/src/emitter.rs | 368 +- crates/formatter/src/aligner.rs | 5 +- crates/formatter/src/formatter.rs | 51 +- crates/languageserver/build.rs | 27 +- crates/languageserver/src/server.rs | 4 +- crates/parser/src/finder.rs | 20 +- crates/parser/src/generated/veryl-exp.par | 1753 +- .../src/generated/veryl_grammar_trait.rs | 5229 +-- crates/parser/src/generated/veryl_parser.rs | 29517 +++++++++------- crates/parser/src/stringifier.rs | 7 + crates/parser/src/veryl_grammar_trait.rs | 63 +- crates/parser/src/veryl_token.rs | 7 +- crates/parser/src/veryl_walker.rs | 103 +- crates/parser/veryl.par | 344 +- testcases/sv/54_generic_function.sv | 17 + testcases/sv/55_generic_module.sv | 32 + testcases/sv/56_generic_interface.sv | 19 + testcases/sv/57_generic_package.sv | 11 + testcases/sv/58_generic_struct.sv | 22 + testcases/veryl/54_generic_function.veryl | 10 + testcases/veryl/55_generic_module.veryl | 20 + testcases/veryl/56_generic_interface.veryl | 16 + testcases/veryl/57_generic_package.veryl | 8 + testcases/veryl/58_generic_struct.veryl | 16 + 40 files changed, 21667 insertions(+), 17276 deletions(-) create mode 100644 crates/analyzer/src/symbol_path.rs create mode 100644 testcases/sv/54_generic_function.sv create mode 100644 testcases/sv/55_generic_module.sv create mode 100644 testcases/sv/56_generic_interface.sv create mode 100644 testcases/sv/57_generic_package.sv create mode 100644 testcases/sv/58_generic_struct.sv create mode 100644 testcases/veryl/54_generic_function.veryl create mode 100644 testcases/veryl/55_generic_module.veryl create mode 100644 testcases/veryl/56_generic_interface.veryl create mode 100644 testcases/veryl/57_generic_package.veryl create mode 100644 testcases/veryl/58_generic_struct.veryl diff --git a/crates/analyzer/src/analyzer.rs b/crates/analyzer/src/analyzer.rs index 1943d25a..35764b23 100644 --- a/crates/analyzer/src/analyzer.rs +++ b/crates/analyzer/src/analyzer.rs @@ -4,17 +4,21 @@ use crate::assign::{AssignPath, AssignPosition, AssignPositionTree, AssignPositi use crate::attribute_table; use crate::handlers::*; use crate::msb_table; +use crate::namespace::Namespace; use crate::namespace_table; use crate::symbol::{ - Direction, ParameterValue, Symbol, SymbolId, SymbolKind, TypeKind, VariableAffiniation, + Direction, DocComment, ParameterValue, Symbol, SymbolId, SymbolKind, TypeKind, + VariableAffiniation, }; -use crate::symbol_table::{self, SymbolPath}; +use crate::symbol_path::SymbolPath; +use crate::symbol_table; use crate::type_dag; use itertools::Itertools; use std::path::Path; use veryl_metadata::{Lint, Metadata}; use veryl_parser::resource_table; use veryl_parser::veryl_grammar_trait::*; +use veryl_parser::veryl_token::{Token, TokenSource}; use veryl_parser::veryl_walker::{Handler, VerylWalker}; pub struct AnalyzerPass1<'a> { @@ -179,15 +183,33 @@ pub struct Analyzer { lint_opt: Lint, } +fn new_namespace(name: &str) -> (Token, Symbol) { + let token = Token::new(name, 0, 0, 0, 0, TokenSource::External); + let symbol = Symbol::new( + &token, + SymbolKind::Namespace, + &Namespace::new(), + false, + DocComment::default(), + ); + (token, symbol) +} + impl Analyzer { pub fn new(metadata: &Metadata) -> Self { for locks in metadata.lockfile.lock_table.values() { for lock in locks { let prj = resource_table::insert_str(&lock.name); + let (token, symbol) = new_namespace(&lock.name); + symbol_table::insert(&token, symbol); for lock_dep in &lock.dependencies { let from = resource_table::insert_str(&lock_dep.name); let to = metadata.lockfile.lock_table.get(&lock_dep.url).unwrap(); let to = to.iter().find(|x| x.version == lock_dep.version).unwrap(); + + let (token, symbol) = new_namespace(&to.name); + symbol_table::insert(&token, symbol); + let to = resource_table::insert_str(&to.name); symbol_table::add_project_local(prj, from, to); } diff --git a/crates/analyzer/src/analyzer_error.rs b/crates/analyzer/src/analyzer_error.rs index 6dfd7650..c4179ab2 100644 --- a/crates/analyzer/src/analyzer_error.rs +++ b/crates/analyzer/src/analyzer_error.rs @@ -219,12 +219,31 @@ pub enum AnalyzerError { #[diagnostic( severity(Error), - code(mismatch_arity), + code(mismatch_function_arity), help("fix function arguments"), - url("https://doc.veryl-lang.org/book/06_appendix/02_semantic_error.html#mismatch_arity") + url("https://doc.veryl-lang.org/book/06_appendix/02_semantic_error.html#mismatch_function_arity") )] #[error("function \"{name}\" has {arity} arguments, but {args} arguments are supplied")] - MismatchArity { + MismatchFunctionArity { + name: String, + arity: usize, + args: usize, + #[source_code] + input: NamedSource, + #[label("Error location")] + error_location: SourceSpan, + }, + + #[diagnostic( + severity(Error), + code(mismatch_generics_arity), + help("fix generics arguments"), + url("https://doc.veryl-lang.org/book/06_appendix/02_semantic_error.html#mismatch_generics_arity") + )] + #[error( + "generics \"{name}\" has {arity} generic arguments, but {args} arguments are supplied" + )] + MismatchGenericsArity { name: String, arity: usize, args: usize, @@ -797,14 +816,30 @@ impl AnalyzerError { } } - pub fn mismatch_arity( + pub fn mismatch_function_arity( + name: &str, + arity: usize, + args: usize, + source: &str, + token: &TokenRange, + ) -> Self { + AnalyzerError::MismatchFunctionArity { + name: name.to_string(), + arity, + args, + input: AnalyzerError::named_source(source, token), + error_location: token.into(), + } + } + + pub fn mismatch_generics_arity( name: &str, arity: usize, args: usize, source: &str, token: &TokenRange, ) -> Self { - AnalyzerError::MismatchArity { + AnalyzerError::MismatchGenericsArity { name: name.to_string(), arity, args, diff --git a/crates/analyzer/src/handlers/check_function.rs b/crates/analyzer/src/handlers/check_function.rs index fc8d026b..2057d2d7 100644 --- a/crates/analyzer/src/handlers/check_function.rs +++ b/crates/analyzer/src/handlers/check_function.rs @@ -1,6 +1,7 @@ use crate::analyzer_error::AnalyzerError; use crate::symbol::SymbolKind; -use crate::symbol_table::{self, SymbolPath}; +use crate::symbol_path::SymbolPath; +use crate::symbol_table; use veryl_parser::veryl_grammar_trait::*; use veryl_parser::veryl_walker::{Handler, HandlerPoint}; use veryl_parser::ParolError; @@ -108,7 +109,7 @@ impl<'a> VerylGrammarTrait for CheckFunction<'a> { .last() .unwrap() ); - self.errors.push(AnalyzerError::mismatch_arity( + self.errors.push(AnalyzerError::mismatch_function_arity( &name, arity, args, diff --git a/crates/analyzer/src/handlers/check_instance.rs b/crates/analyzer/src/handlers/check_instance.rs index 9657a019..6e24eec1 100644 --- a/crates/analyzer/src/handlers/check_instance.rs +++ b/crates/analyzer/src/handlers/check_instance.rs @@ -101,6 +101,7 @@ impl<'a> VerylGrammarTrait for CheckInstance<'a> { } SymbolKind::Interface(_) => (), SymbolKind::SystemVerilog => (), + SymbolKind::GenericParameter => (), _ => { self.errors.push(AnalyzerError::mismatch_type( name, diff --git a/crates/analyzer/src/handlers/check_msb_lsb.rs b/crates/analyzer/src/handlers/check_msb_lsb.rs index a599f9ee..c895de5c 100644 --- a/crates/analyzer/src/handlers/check_msb_lsb.rs +++ b/crates/analyzer/src/handlers/check_msb_lsb.rs @@ -4,7 +4,8 @@ use crate::namespace::Namespace; use crate::namespace_table; use crate::symbol::Type as SymType; use crate::symbol::{SymbolKind, TypeKind}; -use crate::symbol_table::{self, SymbolPath, SymbolPathNamespace}; +use crate::symbol_path::{SymbolPath, SymbolPathNamespace}; +use crate::symbol_table; use veryl_parser::veryl_grammar_trait::*; use veryl_parser::veryl_walker::{Handler, HandlerPoint}; use veryl_parser::ParolError; diff --git a/crates/analyzer/src/handlers/create_reference.rs b/crates/analyzer/src/handlers/create_reference.rs index d8fcb7e8..2e20e192 100644 --- a/crates/analyzer/src/handlers/create_reference.rs +++ b/crates/analyzer/src/handlers/create_reference.rs @@ -2,7 +2,8 @@ use crate::analyzer_error::AnalyzerError; use crate::namespace::Namespace; use crate::namespace_table; use crate::symbol::SymbolKind; -use crate::symbol_table::{self, ResolveError, ResolveErrorCause, SymbolPath}; +use crate::symbol_path::{GenericSymbolPath, SymbolPath}; +use crate::symbol_table::{self, ResolveError, ResolveErrorCause}; use veryl_parser::resource_table::TokenId; use veryl_parser::veryl_grammar_trait::*; use veryl_parser::veryl_token::TokenRange; @@ -17,7 +18,6 @@ pub struct CreateReference<'a> { top_level: bool, file_scope_imported_items: Vec, file_scope_imported_packages: Vec, - in_expression_identifier: Vec<()>, } impl<'a> CreateReference<'a> { @@ -52,6 +52,57 @@ impl<'a> CreateReference<'a> { unreachable!(); } } + + fn generic_symbol_path(&mut self, path: &GenericSymbolPath, namespace: &Namespace) { + if path.is_generic_reference() { + return; + } + + for i in 0..path.len() { + let base_path = path.base_path(i); + + match symbol_table::resolve((&base_path, namespace)) { + Ok(symbol) => { + symbol_table::add_reference(symbol.found.id, &path.paths[0].base); + + // Check number of arguments + let params = symbol.found.generic_parameters().len(); + let args = path.paths[i].arguments.len(); + if params != args { + self.errors.push(AnalyzerError::mismatch_generics_arity( + &path.paths[i].base.to_string(), + params, + args, + self.text, + &path.range, + )); + } else if let Some((token, new_symbol)) = + path.get_generic_instance(i, &symbol.found) + { + if let Some(ref x) = symbol_table::insert(&token, new_symbol) { + symbol_table::add_generic_instance(symbol.found.id, *x); + } + + let table = symbol.found.generic_table(&path.paths[i].arguments); + let mut references = symbol.found.generic_references(); + for path in &mut references { + path.apply_map(&table); + self.generic_symbol_path(path, &symbol.found.inner_namespace()); + } + } + } + Err(err) => { + let single_path = path.paths.len() == 1; + let anonymous = path.paths[0].base.to_string() == "_"; + if single_path && (anonymous || !path.resolvable) { + return; + } + + self.push_resolve_error(err, &path.range); + } + } + } + } } impl<'a> Handler for CreateReference<'a> { @@ -86,49 +137,34 @@ impl<'a> VerylGrammarTrait for CreateReference<'a> { fn scoped_identifier(&mut self, arg: &ScopedIdentifier) -> Result<(), ParolError> { if let HandlerPoint::Before = self.point { - if self.in_expression_identifier.is_empty() { - let ident = arg.identifier().token; - match symbol_table::resolve(arg) { - Ok(symbol) => { - for id in symbol.full_path { - symbol_table::add_reference(id, &ident); - } - } - Err(err) => { - self.push_resolve_error(err, &arg.into()); - } - } - } + let ident = arg.identifier().token; + let path: GenericSymbolPath = arg.into(); + let namespace = namespace_table::get(ident.id).unwrap(); + + self.generic_symbol_path(&path, &namespace); } Ok(()) } fn expression_identifier(&mut self, arg: &ExpressionIdentifier) -> Result<(), ParolError> { - match self.point { - HandlerPoint::Before => { - self.in_expression_identifier.push(()); + // Should be executed after scoped_identifier to handle hierarchical access only + if let HandlerPoint::After = self.point { + let ident = arg.identifier().token; + let mut path: SymbolPath = arg.scoped_identifier.as_ref().into(); + let namespace = namespace_table::get(ident.id).unwrap(); + + for x in &arg.expression_identifier_list0 { + path.push(x.identifier.identifier_token.token.text); - let ident = arg.identifier().token; - match symbol_table::resolve(arg) { + match symbol_table::resolve((&path, &namespace)) { Ok(symbol) => { - for id in symbol.full_path { - symbol_table::add_reference(id, &ident); - } + symbol_table::add_reference(symbol.found.id, &ident); } Err(err) => { - let is_single_identifier = SymbolPath::from(arg).as_slice().len() == 1; - let name = ident.to_string(); - if name == "_" && is_single_identifier { - return Ok(()); - } - self.push_resolve_error(err, &arg.into()); } } } - HandlerPoint::After => { - self.in_expression_identifier.pop(); - } } Ok(()) } diff --git a/crates/analyzer/src/handlers/create_symbol_table.rs b/crates/analyzer/src/handlers/create_symbol_table.rs index 8b0cbdbc..174c9a40 100644 --- a/crates/analyzer/src/handlers/create_symbol_table.rs +++ b/crates/analyzer/src/handlers/create_symbol_table.rs @@ -13,7 +13,8 @@ use crate::symbol::{ StructProperty, Symbol, SymbolId, SymbolKind, TypeDefProperty, TypeKind, UnionMemberProperty, UnionProperty, VariableAffiniation, VariableProperty, }; -use crate::symbol_table::{self, SymbolPath}; +use crate::symbol_path::{GenericSymbolPath, SymbolPath}; +use crate::symbol_table; use std::collections::{HashMap, HashSet}; use veryl_parser::doc_comment_table; use veryl_parser::resource_table::{self, StrId}; @@ -39,6 +40,8 @@ pub struct CreateSymbolTable<'a> { affiniation: Vec, connect_targets: Vec>, connects: HashMap>>, + generic_parameters: Vec, + generic_references: Vec, } #[derive(Clone)] @@ -136,27 +139,36 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { } fn scoped_identifier(&mut self, arg: &ScopedIdentifier) -> Result<(), ParolError> { - if let HandlerPoint::Before = self.point { - // Add symbols under $sv namespace - if let ScopedIdentifierGroup::DollarIdentifier(x) = arg.scoped_identifier_group.as_ref() - { - if x.dollar_identifier.dollar_identifier_token.to_string() == "$sv" { - let mut namespace = Namespace::new(); - for (i, token) in scoped_identifier_tokens(arg).iter().enumerate() { - if i != 0 { - let symbol = Symbol::new( - token, - SymbolKind::SystemVerilog, - &namespace, - false, - DocComment::default(), - ); - let _ = symbol_table::insert(token, symbol); + match self.point { + HandlerPoint::Before => { + // Add symbols under $sv namespace + if let ScopedIdentifierGroup::DollarIdentifier(x) = + arg.scoped_identifier_group.as_ref() + { + if x.dollar_identifier.dollar_identifier_token.to_string() == "$sv" { + let mut namespace = Namespace::new(); + for (i, token) in scoped_identifier_tokens(arg).iter().enumerate() { + if i != 0 { + let symbol = Symbol::new( + token, + SymbolKind::SystemVerilog, + &namespace, + false, + DocComment::default(), + ); + let _ = symbol_table::insert(token, symbol); + } + namespace.push(token.text); } - namespace.push(token.text); } } } + HandlerPoint::After => { + let path: GenericSymbolPath = arg.into(); + if path.is_generic_reference() { + self.generic_references.push(path); + } + } } Ok(()) } @@ -351,6 +363,8 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { } fn struct_union_declaration(&mut self, arg: &StructUnionDeclaration) -> Result<(), ParolError> { + let name = arg.identifier.identifier_token.token.text; + match self.point { HandlerPoint::Before => { self.struct_or_union = match &*arg.struct_union { @@ -358,21 +372,31 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { StructUnion::Union(_) => Some(StructOrUnion::InUnion), }; - let name = arg.identifier.identifier_token.token.text; self.namespace.push(name); } HandlerPoint::After => { self.struct_or_union = None; self.namespace.pop(); + let generic_parameters: Vec<_> = self.generic_parameters.drain(..).collect(); + let generic_references: Vec<_> = self.generic_references.drain(..).collect(); + let members: Vec<_> = self.struct_union_members.drain(0..).flatten().collect(); let kind = match &*arg.struct_union { StructUnion::Struct(_) => { - let property = StructProperty { members }; + let property = StructProperty { + members, + generic_parameters, + generic_references, + }; SymbolKind::Struct(property) } StructUnion::Union(_) => { - let property = UnionProperty { members }; + let property = UnionProperty { + members, + generic_parameters, + generic_references, + }; SymbolKind::Union(property) } }; @@ -482,6 +506,21 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { Ok(()) } + fn with_generic_parameter_item( + &mut self, + arg: &WithGenericParameterItem, + ) -> Result<(), ParolError> { + if let HandlerPoint::Before = self.point { + let kind = SymbolKind::GenericParameter; + if let Some(id) = + self.insert_symbol(&arg.identifier.identifier_token.token, kind, false) + { + self.generic_parameters.push(id); + } + } + Ok(()) + } + fn port_declaration_item(&mut self, arg: &PortDeclarationItem) -> Result<(), ParolError> { if let HandlerPoint::Before = self.point { let token = arg.identifier.identifier_token.token; @@ -508,10 +547,22 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { } fn function_declaration(&mut self, arg: &FunctionDeclaration) -> Result<(), ParolError> { + let name = arg.identifier.identifier_token.token.text; match self.point { HandlerPoint::Before => { + self.namespace.push(name); + self.affiniation.push(VariableAffiniation::Function); + } + HandlerPoint::After => { + self.namespace.pop(); + self.affiniation.pop(); + + let generic_parameters: Vec<_> = self.generic_parameters.drain(..).collect(); + let generic_references: Vec<_> = self.generic_references.drain(..).collect(); + + // TODO as the same as generic_parameters let mut ports = Vec::new(); - if let Some(ref x) = arg.function_declaration_opt { + if let Some(ref x) = arg.function_declaration_opt0 { if let Some(ref x) = x.port_declaration.port_declaration_opt { let items: Vec = x.port_declaration_list.as_ref().into(); @@ -520,37 +571,49 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { } } } + let ret = arg - .function_declaration_opt0 + .function_declaration_opt1 .as_ref() .map(|x| (&*x.scalar_type).into()); + let range = TokenRange::new(&arg.function.function_token, &arg.r_brace.r_brace_token); - let property = FunctionProperty { range, ports, ret }; + + let property = FunctionProperty { + range, + generic_parameters, + generic_references, + ports, + ret, + }; self.insert_symbol( &arg.identifier.identifier_token.token, SymbolKind::Function(property), false, ); - - let name = arg.identifier.identifier_token.token.text; - self.namespace.push(name); - self.affiniation.push(VariableAffiniation::Function); - } - HandlerPoint::After => { - self.namespace.pop(); - self.affiniation.pop(); } } Ok(()) } fn module_declaration(&mut self, arg: &ModuleDeclaration) -> Result<(), ParolError> { + let name = arg.identifier.identifier_token.token.text; match self.point { HandlerPoint::Before => { + self.namespace.push(name); + self.affiniation.push(VariableAffiniation::Module); + } + HandlerPoint::After => { + self.namespace.pop(); + self.affiniation.pop(); + + let generic_parameters: Vec<_> = self.generic_parameters.drain(..).collect(); + let generic_references: Vec<_> = self.generic_references.drain(..).collect(); + + // TODO as the same as generic_parameters let mut parameters = Vec::new(); - let public = arg.module_declaration_opt.is_some(); - if let Some(ref x) = arg.module_declaration_opt0 { + if let Some(ref x) = arg.module_declaration_opt1 { if let Some(ref x) = x.with_parameter.with_parameter_opt { let items: Vec = x.with_parameter_list.as_ref().into(); for item in items { @@ -558,8 +621,10 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { } } } + + // TODO as the same as generic_parameters let mut ports = Vec::new(); - if let Some(ref x) = arg.module_declaration_opt1 { + if let Some(ref x) = arg.module_declaration_opt2 { if let Some(ref x) = x.port_declaration.port_declaration_opt { let items: Vec = x.port_declaration_list.as_ref().into(); @@ -568,25 +633,22 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { } } } + let range = TokenRange::new(&arg.module.module_token, &arg.r_brace.r_brace_token); + let property = ModuleProperty { range, + generic_parameters, + generic_references, parameters, ports, }; + let public = arg.module_declaration_opt.is_some(); self.insert_symbol( &arg.identifier.identifier_token.token, SymbolKind::Module(property), public, ); - - let name = arg.identifier.identifier_token.token.text; - self.namespace.push(name); - self.affiniation.push(VariableAffiniation::Module); - } - HandlerPoint::After => { - self.namespace.pop(); - self.affiniation.pop(); } } Ok(()) @@ -658,11 +720,22 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { } fn interface_declaration(&mut self, arg: &InterfaceDeclaration) -> Result<(), ParolError> { + let name = arg.identifier.identifier_token.token.text; match self.point { HandlerPoint::Before => { + self.namespace.push(name); + self.affiniation.push(VariableAffiniation::Intarface); + } + HandlerPoint::After => { + self.namespace.pop(); + self.affiniation.pop(); + + let generic_parameters: Vec<_> = self.generic_parameters.drain(..).collect(); + let generic_references: Vec<_> = self.generic_references.drain(..).collect(); + + // TODO as the same as generic_parameters let mut parameters = Vec::new(); - let public = arg.interface_declaration_opt.is_some(); - if let Some(ref x) = arg.interface_declaration_opt0 { + if let Some(ref x) = arg.interface_declaration_opt1 { if let Some(ref x) = x.with_parameter.with_parameter_opt { let items: Vec = x.with_parameter_list.as_ref().into(); for item in items { @@ -670,22 +743,22 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { } } } + let range = TokenRange::new(&arg.interface.interface_token, &arg.r_brace.r_brace_token); - let property = InterfaceProperty { range, parameters }; + + let property = InterfaceProperty { + range, + generic_parameters, + generic_references, + parameters, + }; + let public = arg.interface_declaration_opt.is_some(); self.insert_symbol( &arg.identifier.identifier_token.token, SymbolKind::Interface(property), public, ); - - let name = arg.identifier.identifier_token.token.text; - self.namespace.push(name); - self.affiniation.push(VariableAffiniation::Intarface); - } - HandlerPoint::After => { - self.namespace.pop(); - self.affiniation.pop(); } } Ok(()) @@ -760,24 +833,32 @@ impl<'a> VerylGrammarTrait for CreateSymbolTable<'a> { } fn package_declaration(&mut self, arg: &PackageDeclaration) -> Result<(), ParolError> { + let name = arg.identifier.identifier_token.token.text; match self.point { HandlerPoint::Before => { - let public = arg.package_declaration_opt.is_some(); - let range = TokenRange::new(&arg.package.package_token, &arg.r_brace.r_brace_token); - let property = PackageProperty { range }; - self.insert_symbol( - &arg.identifier.identifier_token.token, - SymbolKind::Package(property), - public, - ); - - let name = arg.identifier.identifier_token.token.text; self.namespace.push(name); self.affiniation.push(VariableAffiniation::Package); } HandlerPoint::After => { self.namespace.pop(); self.affiniation.pop(); + + let generic_parameters: Vec<_> = self.generic_parameters.drain(..).collect(); + let generic_references: Vec<_> = self.generic_references.drain(..).collect(); + + let range = TokenRange::new(&arg.package.package_token, &arg.r_brace.r_brace_token); + + let property = PackageProperty { + range, + generic_parameters, + generic_references, + }; + let public = arg.package_declaration_opt.is_some(); + self.insert_symbol( + &arg.identifier.identifier_token.token, + SymbolKind::Package(property), + public, + ); } } Ok(()) diff --git a/crates/analyzer/src/handlers/create_type_dag.rs b/crates/analyzer/src/handlers/create_type_dag.rs index 330d5cc2..95c86084 100644 --- a/crates/analyzer/src/handlers/create_type_dag.rs +++ b/crates/analyzer/src/handlers/create_type_dag.rs @@ -1,6 +1,6 @@ use crate::{ analyzer_error::AnalyzerError, - symbol_table::SymbolPathNamespace, + symbol_path::{GenericSymbolPath, SymbolPathNamespace}, type_dag::{self, Context, DagError}, }; use std::collections::HashMap; @@ -173,6 +173,11 @@ impl<'a> VerylGrammarTrait for CreateTypeDag<'a> { fn scoped_identifier(&mut self, arg: &ScopedIdentifier) -> Result<(), ParolError> { if let HandlerPoint::Before = self.point { if !self.ctx.is_empty() && self.ctx.last() != Some(&Context::ExpressionIdentifier) { + let path: GenericSymbolPath = arg.into(); + if path.is_generic_reference() { + return Ok(()); + } + let path: SymbolPathNamespace = arg.into(); let name = to_string(arg); let token = arg.identifier().token; diff --git a/crates/analyzer/src/lib.rs b/crates/analyzer/src/lib.rs index c8a831fa..98f47ccf 100644 --- a/crates/analyzer/src/lib.rs +++ b/crates/analyzer/src/lib.rs @@ -9,6 +9,7 @@ pub mod msb_table; pub mod namespace; pub mod namespace_table; pub mod symbol; +pub mod symbol_path; pub mod symbol_table; pub mod type_dag; pub use analyzer::Analyzer; diff --git a/crates/analyzer/src/namespace.rs b/crates/analyzer/src/namespace.rs index 4a749b3f..76f182af 100644 --- a/crates/analyzer/src/namespace.rs +++ b/crates/analyzer/src/namespace.rs @@ -1,5 +1,6 @@ use crate::namespace_table; -use crate::symbol_table::SymbolPath; +use crate::symbol_path::SymbolPath; +use std::collections::HashMap; use std::fmt; use veryl_parser::resource_table::StrId; @@ -45,6 +46,18 @@ impl Namespace { self.included(x) } } + + pub fn replace(&self, table: &HashMap) -> Self { + let mut paths = Vec::new(); + for x in &self.paths { + if let Some(x) = table.get(x) { + paths.push(*x); + } else { + paths.push(*x); + } + } + Self { paths } + } } impl Default for Namespace { diff --git a/crates/analyzer/src/symbol.rs b/crates/analyzer/src/symbol.rs index dca8adfe..a7e7cf55 100644 --- a/crates/analyzer/src/symbol.rs +++ b/crates/analyzer/src/symbol.rs @@ -1,5 +1,7 @@ use crate::evaluator::{Evaluated, Evaluator}; use crate::namespace::Namespace; +use crate::symbol_path::GenericSymbolPath; +use crate::symbol_table; use std::cell::{Cell, RefCell}; use std::collections::HashMap; use std::fmt; @@ -44,6 +46,18 @@ impl DocComment { } } +#[derive(Clone, Debug, Default)] +pub struct GenericMap { + pub name: String, + pub map: HashMap, +} + +impl GenericMap { + pub fn generic(&self) -> bool { + !self.map.is_empty() + } +} + #[derive(Debug, Clone)] pub struct Symbol { pub token: Token, @@ -51,6 +65,7 @@ pub struct Symbol { pub kind: SymbolKind, pub namespace: Namespace, pub references: Vec, + pub generic_instances: Vec, pub imported: Vec, pub evaluated: Cell>, pub allow_unused: bool, @@ -72,6 +87,7 @@ impl Symbol { kind, namespace: namespace.to_owned(), references: Vec::new(), + generic_instances: Vec::new(), imported: Vec::new(), evaluated: Cell::new(None), allow_unused: false, @@ -115,6 +131,100 @@ impl Symbol { ret.push(self.token.text); ret } + + pub fn generic_maps(&self) -> Vec { + let mut ret = Vec::new(); + + let prefix = if matches!( + self.kind, + SymbolKind::Module(_) | SymbolKind::Interface(_) | SymbolKind::Package(_) + ) { + format!("{}_", self.namespace) + } else { + "".to_string() + }; + + for i in &self.generic_instances { + let symbol = symbol_table::get(*i).unwrap(); + let map = if let SymbolKind::GenericInstance(ref x) = symbol.kind { + self.generic_table(&x.arguments) + } else { + HashMap::new() + }; + let name = format!("{}{}", prefix, symbol.token.text); + ret.push(GenericMap { name, map }); + } + + // empty map for non-generic + if ret.is_empty() { + ret.push(GenericMap::default()); + } + ret + } + + pub fn generic_table( + &self, + arguments: &[GenericSymbolPath], + ) -> HashMap { + let generic_parameters = self.generic_parameters(); + let mut ret = HashMap::new(); + + for (i, arg) in arguments.iter().enumerate() { + if let Some(p) = generic_parameters.get(i) { + ret.insert(*p, arg.clone()); + } + } + + ret + } + + pub fn generic_parameters(&self) -> Vec { + match &self.kind { + SymbolKind::Function(x) => x + .generic_parameters + .iter() + .map(|x| symbol_table::get(*x).unwrap().token.text) + .collect(), + SymbolKind::Module(x) => x + .generic_parameters + .iter() + .map(|x| symbol_table::get(*x).unwrap().token.text) + .collect(), + SymbolKind::Interface(x) => x + .generic_parameters + .iter() + .map(|x| symbol_table::get(*x).unwrap().token.text) + .collect(), + SymbolKind::Package(x) => x + .generic_parameters + .iter() + .map(|x| symbol_table::get(*x).unwrap().token.text) + .collect(), + SymbolKind::Struct(x) => x + .generic_parameters + .iter() + .map(|x| symbol_table::get(*x).unwrap().token.text) + .collect(), + SymbolKind::Union(x) => x + .generic_parameters + .iter() + .map(|x| symbol_table::get(*x).unwrap().token.text) + .collect(), + _ => Vec::new(), + } + } + + pub fn generic_references(&self) -> Vec { + match &self.kind { + SymbolKind::Function(x) => x.generic_references.clone(), + SymbolKind::Module(x) => x.generic_references.clone(), + SymbolKind::Interface(x) => x.generic_references.clone(), + SymbolKind::Package(x) => x.generic_references.clone(), + SymbolKind::Struct(x) => x.generic_references.clone(), + SymbolKind::Union(x) => x.generic_references.clone(), + _ => Vec::new(), + } + } } #[derive(Debug, Clone)] @@ -141,6 +251,8 @@ pub enum SymbolKind { SystemVerilog, Namespace, SystemFunction, + GenericParameter, + GenericInstance(GenericInstanceProperty), } impl SymbolKind { @@ -168,6 +280,8 @@ impl SymbolKind { SymbolKind::SystemVerilog => "systemverilog item".to_string(), SymbolKind::Namespace => "namespace".to_string(), SymbolKind::SystemFunction => "system function".to_string(), + SymbolKind::GenericParameter => "generic parameter".to_string(), + SymbolKind::GenericInstance(_) => "generic instance".to_string(), } } } @@ -187,16 +301,25 @@ impl fmt::Display for SymbolKind { } SymbolKind::Module(x) => { format!( - "module ({} params, {} ports)", + "module ({} generic, {} params, {} ports)", + x.generic_parameters.len(), x.parameters.len(), x.ports.len() ) } SymbolKind::Interface(x) => { - format!("interface ({} params)", x.parameters.len()) + format!( + "interface ({} generic, {} params)", + x.generic_parameters.len(), + x.parameters.len() + ) } SymbolKind::Function(x) => { - format!("function ({} args)", x.ports.len()) + format!( + "function ({} generic, {} args)", + x.generic_parameters.len(), + x.ports.len() + ) } SymbolKind::Parameter(x) => { let mut stringifier = Stringifier::new(); @@ -224,7 +347,9 @@ impl fmt::Display for SymbolKind { format!("instance ({type_name})") } SymbolKind::Block => "block".to_string(), - SymbolKind::Package(_) => "package".to_string(), + SymbolKind::Package(x) => { + format!("package ({} generic)", x.generic_parameters.len()) + } SymbolKind::Struct(_) => "struct".to_string(), SymbolKind::StructMember(x) => { format!("struct member ({})", x.r#type) @@ -256,6 +381,8 @@ impl fmt::Display for SymbolKind { SymbolKind::SystemVerilog => "systemverilog item".to_string(), SymbolKind::Namespace => "namespace".to_string(), SymbolKind::SystemFunction => "system function".to_string(), + SymbolKind::GenericParameter => "generic parameter".to_string(), + SymbolKind::GenericInstance(_) => "generic instance".to_string(), }; text.fmt(f) } @@ -424,7 +551,9 @@ impl From<&syntax_tree::ScalarType> for Type { let x = &x.scoped_identifier; let mut name = Vec::new(); match &*x.scoped_identifier_group { - syntax_tree::ScopedIdentifierGroup::Identifier(x) => { + syntax_tree::ScopedIdentifierGroup::IdentifierScopedIdentifierOpt( + x, + ) => { name.push(x.identifier.identifier_token.token.text); } syntax_tree::ScopedIdentifierGroup::DollarIdentifier(x) => { @@ -635,6 +764,8 @@ impl From<&syntax_tree::WithParameterItem> for Parameter { #[derive(Debug, Clone)] pub struct ModuleProperty { pub range: TokenRange, + pub generic_parameters: Vec, + pub generic_references: Vec, pub parameters: Vec, pub ports: Vec, } @@ -642,12 +773,16 @@ pub struct ModuleProperty { #[derive(Debug, Clone)] pub struct InterfaceProperty { pub range: TokenRange, + pub generic_parameters: Vec, + pub generic_references: Vec, pub parameters: Vec, } #[derive(Debug, Clone)] pub struct FunctionProperty { pub range: TokenRange, + pub generic_parameters: Vec, + pub generic_references: Vec, pub ports: Vec, pub ret: Option, } @@ -661,11 +796,15 @@ pub struct InstanceProperty { #[derive(Debug, Clone)] pub struct PackageProperty { pub range: TokenRange, + pub generic_parameters: Vec, + pub generic_references: Vec, } #[derive(Debug, Clone)] pub struct StructProperty { pub members: Vec, + pub generic_parameters: Vec, + pub generic_references: Vec, } #[derive(Debug, Clone)] @@ -676,6 +815,8 @@ pub struct StructMemberProperty { #[derive(Debug, Clone)] pub struct UnionProperty { pub members: Vec, + pub generic_parameters: Vec, + pub generic_references: Vec, } #[derive(Debug, Clone)] @@ -709,3 +850,9 @@ pub struct ModportProperty { pub struct ModportMemberProperty { pub direction: Direction, } + +#[derive(Debug, Clone)] +pub struct GenericInstanceProperty { + pub base: SymbolId, + pub arguments: Vec, +} diff --git a/crates/analyzer/src/symbol_path.rs b/crates/analyzer/src/symbol_path.rs new file mode 100644 index 00000000..2e32d8d0 --- /dev/null +++ b/crates/analyzer/src/symbol_path.rs @@ -0,0 +1,434 @@ +use crate::namespace::Namespace; +use crate::namespace_table; +use crate::symbol::{DocComment, GenericInstanceProperty, Symbol, SymbolKind}; +use crate::symbol_table; +use std::cmp::Ordering; +use std::collections::HashMap; +use std::fmt; +use veryl_parser::resource_table::{self, StrId}; +use veryl_parser::veryl_grammar_trait as syntax_tree; +use veryl_parser::veryl_token::{Token, TokenRange}; + +#[derive(Debug, Default, Clone, PartialEq)] +pub struct SymbolPath(pub Vec); + +impl SymbolPath { + pub fn new(x: &[StrId]) -> Self { + Self(x.to_vec()) + } + + pub fn push(&mut self, x: StrId) { + self.0.push(x) + } + + pub fn pop(&mut self) -> Option { + self.0.pop() + } + + pub fn clear(&mut self) { + self.0.clear() + } + + pub fn as_slice(&self) -> &[StrId] { + self.0.as_slice() + } + + pub fn to_vec(self) -> Vec { + self.0 + } +} + +impl fmt::Display for SymbolPath { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let mut text = String::new(); + for path in self.as_slice() { + text.push_str(&format!("{path} ")); + } + text.fmt(f) + } +} + +impl From<&[Token]> for SymbolPath { + fn from(value: &[Token]) -> Self { + let mut path = Vec::new(); + for x in value { + path.push(x.text); + } + SymbolPath(path) + } +} + +impl From<&Token> for SymbolPath { + fn from(value: &Token) -> Self { + let path = vec![value.text]; + SymbolPath(path) + } +} + +impl From<&syntax_tree::Identifier> for SymbolPath { + fn from(value: &syntax_tree::Identifier) -> Self { + let path = vec![value.identifier_token.token.text]; + SymbolPath(path) + } +} + +impl From<&[syntax_tree::Identifier]> for SymbolPath { + fn from(value: &[syntax_tree::Identifier]) -> Self { + let mut path = Vec::new(); + for x in value { + path.push(x.identifier_token.token.text); + } + SymbolPath(path) + } +} + +impl From<&syntax_tree::HierarchicalIdentifier> for SymbolPath { + fn from(value: &syntax_tree::HierarchicalIdentifier) -> Self { + let mut path = Vec::new(); + path.push(value.identifier.identifier_token.token.text); + for x in &value.hierarchical_identifier_list0 { + path.push(x.identifier.identifier_token.token.text); + } + SymbolPath(path) + } +} + +impl From<&syntax_tree::ScopedIdentifier> for SymbolPath { + fn from(value: &syntax_tree::ScopedIdentifier) -> Self { + let path: GenericSymbolPath = value.into(); + path.mangled_path() + } +} + +impl From<&syntax_tree::ExpressionIdentifier> for SymbolPath { + fn from(value: &syntax_tree::ExpressionIdentifier) -> Self { + let mut path: SymbolPath = value.scoped_identifier.as_ref().into(); + for x in &value.expression_identifier_list0 { + path.push(x.identifier.identifier_token.token.text); + } + path + } +} + +#[derive(Clone, Default, Debug)] +pub struct SymbolPathNamespace(pub SymbolPath, pub Namespace); + +impl From<&Token> for SymbolPathNamespace { + fn from(value: &Token) -> Self { + let namespace = namespace_table::get(value.id).unwrap(); + SymbolPathNamespace(value.into(), namespace) + } +} + +impl From<&SymbolPathNamespace> for SymbolPathNamespace { + fn from(value: &SymbolPathNamespace) -> Self { + value.clone() + } +} + +impl From<(&SymbolPath, &Namespace)> for SymbolPathNamespace { + fn from(value: (&SymbolPath, &Namespace)) -> Self { + SymbolPathNamespace(value.0.clone(), value.1.clone()) + } +} + +impl From<(&Token, &Namespace)> for SymbolPathNamespace { + fn from(value: (&Token, &Namespace)) -> Self { + let path = SymbolPath::new(&[value.0.text]); + SymbolPathNamespace(path, value.1.clone()) + } +} + +impl From<(&Vec, &Namespace)> for SymbolPathNamespace { + fn from(value: (&Vec, &Namespace)) -> Self { + let path = SymbolPath::new(value.0); + SymbolPathNamespace(path, value.1.clone()) + } +} + +impl From<&syntax_tree::Identifier> for SymbolPathNamespace { + fn from(value: &syntax_tree::Identifier) -> Self { + let namespace = namespace_table::get(value.identifier_token.token.id).unwrap(); + SymbolPathNamespace(value.into(), namespace) + } +} + +impl From<&[syntax_tree::Identifier]> for SymbolPathNamespace { + fn from(value: &[syntax_tree::Identifier]) -> Self { + let namespace = namespace_table::get(value[0].identifier_token.token.id).unwrap(); + SymbolPathNamespace(value.into(), namespace) + } +} + +impl From<&syntax_tree::HierarchicalIdentifier> for SymbolPathNamespace { + fn from(value: &syntax_tree::HierarchicalIdentifier) -> Self { + let namespace = namespace_table::get(value.identifier.identifier_token.token.id).unwrap(); + SymbolPathNamespace(value.into(), namespace) + } +} + +impl From<&syntax_tree::ScopedIdentifier> for SymbolPathNamespace { + fn from(value: &syntax_tree::ScopedIdentifier) -> Self { + let namespace = namespace_table::get(value.identifier().token.id).unwrap(); + SymbolPathNamespace(value.into(), namespace) + } +} + +impl From<&syntax_tree::ExpressionIdentifier> for SymbolPathNamespace { + fn from(value: &syntax_tree::ExpressionIdentifier) -> Self { + let namespace = namespace_table::get(value.identifier().token.id).unwrap(); + SymbolPathNamespace(value.into(), namespace) + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GenericSymbolPath { + pub paths: Vec, + pub resolvable: bool, + pub range: TokenRange, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GenericSymbol { + pub base: Token, + pub arguments: Vec, +} + +impl GenericSymbol { + pub fn base(&self) -> StrId { + self.base.text + } + + pub fn mangled(&self) -> StrId { + if self.arguments.is_empty() { + self.base() + } else { + let mut text = format!("__{}", self.base); + for a in &self.arguments { + text.push('_'); + for a in a.mangled_path().0.as_slice() { + text.push_str(&format!("_{}", a)); + } + } + resource_table::insert_str(&text) + } + } +} + +impl GenericSymbolPath { + pub fn len(&self) -> usize { + self.paths.len() + } + + pub fn is_empty(&self) -> bool { + self.paths.is_empty() + } + + pub fn base_path(&self, i: usize) -> SymbolPath { + let path: Vec<_> = self + .paths + .iter() + .enumerate() + .filter_map(|(j, x)| match i.cmp(&j) { + Ordering::Greater => Some(x.mangled()), + Ordering::Equal => Some(x.base()), + Ordering::Less => None, + }) + .collect(); + SymbolPath::new(&path) + } + + pub fn mangled_path(&self) -> SymbolPath { + let path: Vec<_> = self.paths.iter().map(|x| x.mangled()).collect(); + SymbolPath::new(&path) + } + + pub fn get_generic_instance(&self, i: usize, base: &Symbol) -> Option<(Token, Symbol)> { + if self.paths[i].arguments.is_empty() { + None + } else { + let path = &self.paths[i]; + let arguments = path.arguments.clone(); + let property = GenericInstanceProperty { + base: base.id, + arguments, + }; + let kind = SymbolKind::GenericInstance(property); + let token = &path.base; + let token = Token::new( + &path.mangled().to_string(), + token.line, + token.column, + token.length, + token.pos, + token.source, + ); + let symbol = Symbol::new(&token, kind, &base.namespace, false, DocComment::default()); + Some((token, symbol)) + } + } + + pub fn is_generic(&self) -> bool { + for path in &self.paths { + if !path.arguments.is_empty() { + return true; + } + } + false + } + + pub fn is_generic_reference(&self) -> bool { + // path starts with generic parameter + if !self.resolvable { + return false; + } + let head = &self.paths[0]; + if let Ok(symbol) = symbol_table::resolve(&head.base) { + if matches!(symbol.found.kind, SymbolKind::GenericParameter) { + return true; + } + } + + // path contains generic parameter as generic argument + for path in &self.paths { + for arg in &path.arguments { + if !arg.resolvable { + continue; + } + let head = &arg.paths[0]; + if let Ok(symbol) = symbol_table::resolve(&head.base) { + if matches!(symbol.found.kind, SymbolKind::GenericParameter) { + return true; + } + } + } + } + + false + } + + pub fn apply_map(&mut self, map: &HashMap) { + let head = &self.paths[0]; + if let Some(x) = map.get(&head.base()) { + let mut paths: Vec<_> = self.paths.drain(1..).collect(); + self.paths.clone_from(&x.paths); + self.paths.append(&mut paths); + self.resolvable = x.resolvable; + } + + for path in &mut self.paths { + for arg in &mut path.arguments { + let head = &arg.paths[0]; + if let Some(x) = map.get(&head.base()) { + let mut paths: Vec<_> = arg.paths.drain(1..).collect(); + arg.paths.clone_from(&x.paths); + arg.paths.append(&mut paths); + } + } + } + } +} + +impl From<&syntax_tree::Number> for GenericSymbolPath { + fn from(value: &syntax_tree::Number) -> Self { + let token = match value { + syntax_tree::Number::IntegralNumber(x) => match x.integral_number.as_ref() { + syntax_tree::IntegralNumber::Based(x) => x.based.based_token.token, + syntax_tree::IntegralNumber::AllBit(x) => x.all_bit.all_bit_token.token, + syntax_tree::IntegralNumber::BaseLess(x) => x.base_less.base_less_token.token, + }, + syntax_tree::Number::RealNumber(x) => match x.real_number.as_ref() { + syntax_tree::RealNumber::Exponent(x) => x.exponent.exponent_token.token, + syntax_tree::RealNumber::FixedPoint(x) => x.fixed_point.fixed_point_token.token, + }, + }; + GenericSymbolPath { + paths: vec![GenericSymbol { + base: token, + arguments: Vec::new(), + }], + resolvable: false, + range: token.into(), + } + } +} + +impl From<&syntax_tree::ScopedIdentifier> for GenericSymbolPath { + fn from(value: &syntax_tree::ScopedIdentifier) -> Self { + let mut paths = Vec::new(); + match value.scoped_identifier_group.as_ref() { + syntax_tree::ScopedIdentifierGroup::DollarIdentifier(x) => { + let base = x.dollar_identifier.dollar_identifier_token.token; + paths.push(GenericSymbol { + base, + arguments: Vec::new(), + }); + } + syntax_tree::ScopedIdentifierGroup::IdentifierScopedIdentifierOpt(x) => { + let base = x.identifier.identifier_token.token; + let mut arguments = Vec::new(); + + if let Some(ref x) = x.scoped_identifier_opt { + let list: Vec = x + .with_generic_argument + .with_generic_argument_list + .as_ref() + .into(); + for x in list { + match x { + syntax_tree::WithGenericArgumentItem::ScopedIdentifier(x) => { + arguments.push(x.scoped_identifier.as_ref().into()); + } + syntax_tree::WithGenericArgumentItem::Number(x) => { + arguments.push(x.number.as_ref().into()); + } + } + } + } + + paths.push(GenericSymbol { base, arguments }); + } + } + + for x in &value.scoped_identifier_list { + let base = x.identifier.identifier_token.token; + let mut arguments = Vec::new(); + + if let Some(ref x) = x.scoped_identifier_opt0 { + let list: Vec = x + .with_generic_argument + .with_generic_argument_list + .as_ref() + .into(); + for x in list { + match x { + syntax_tree::WithGenericArgumentItem::ScopedIdentifier(x) => { + arguments.push(x.scoped_identifier.as_ref().into()); + } + syntax_tree::WithGenericArgumentItem::Number(x) => { + arguments.push(x.number.as_ref().into()); + } + } + } + } + + paths.push(GenericSymbol { base, arguments }); + } + + GenericSymbolPath { + paths, + resolvable: true, + range: value.into(), + } + } +} + +impl fmt::Display for GenericSymbolPath { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let mut text = String::new(); + for path in &self.paths { + text.push_str(&format!("{} ", path.mangled())); + } + text.fmt(f) + } +} diff --git a/crates/analyzer/src/symbol_table.rs b/crates/analyzer/src/symbol_table.rs index 66e40a8d..4ed1fa7f 100644 --- a/crates/analyzer/src/symbol_table.rs +++ b/crates/analyzer/src/symbol_table.rs @@ -1,191 +1,14 @@ use crate::assign::{Assign, AssignPath, AssignPosition}; use crate::evaluator::Evaluated; use crate::namespace::Namespace; -use crate::namespace_table; use crate::symbol::{DocComment, Symbol, SymbolId, SymbolKind, TypeKind}; +use crate::symbol_path::{SymbolPath, SymbolPathNamespace}; use std::cell::RefCell; use std::collections::HashMap; use std::fmt; use veryl_parser::resource_table::{PathId, StrId, TokenId}; -use veryl_parser::veryl_grammar_trait as syntax_tree; use veryl_parser::veryl_token::{Token, TokenSource}; -#[derive(Debug, Default, Clone, PartialEq)] -pub struct SymbolPath(Vec); - -impl SymbolPath { - pub fn new(x: &[StrId]) -> Self { - Self(x.to_vec()) - } - - pub fn push(&mut self, x: StrId) { - self.0.push(x) - } - - pub fn pop(&mut self) -> Option { - self.0.pop() - } - - pub fn clear(&mut self) { - self.0.clear() - } - - pub fn as_slice(&self) -> &[StrId] { - self.0.as_slice() - } - - pub fn to_vec(self) -> Vec { - self.0 - } -} - -impl fmt::Display for SymbolPath { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let mut text = String::new(); - for path in self.as_slice() { - text.push_str(&format!("{path} ")); - } - text.fmt(f) - } -} - -impl From<&[Token]> for SymbolPath { - fn from(value: &[Token]) -> Self { - let mut path = Vec::new(); - for x in value { - path.push(x.text); - } - SymbolPath(path) - } -} - -impl From<&Token> for SymbolPath { - fn from(value: &Token) -> Self { - let path = vec![value.text]; - SymbolPath(path) - } -} - -impl From<&syntax_tree::Identifier> for SymbolPath { - fn from(value: &syntax_tree::Identifier) -> Self { - let path = vec![value.identifier_token.token.text]; - SymbolPath(path) - } -} - -impl From<&[syntax_tree::Identifier]> for SymbolPath { - fn from(value: &[syntax_tree::Identifier]) -> Self { - let mut path = Vec::new(); - for x in value { - path.push(x.identifier_token.token.text); - } - SymbolPath(path) - } -} - -impl From<&syntax_tree::HierarchicalIdentifier> for SymbolPath { - fn from(value: &syntax_tree::HierarchicalIdentifier) -> Self { - let mut path = Vec::new(); - path.push(value.identifier.identifier_token.token.text); - for x in &value.hierarchical_identifier_list0 { - path.push(x.identifier.identifier_token.token.text); - } - SymbolPath(path) - } -} - -impl From<&syntax_tree::ScopedIdentifier> for SymbolPath { - fn from(value: &syntax_tree::ScopedIdentifier) -> Self { - let mut path = Vec::new(); - path.push(value.identifier().token.text); - for x in &value.scoped_identifier_list { - path.push(x.identifier.identifier_token.token.text); - } - SymbolPath(path) - } -} - -impl From<&syntax_tree::ExpressionIdentifier> for SymbolPath { - fn from(value: &syntax_tree::ExpressionIdentifier) -> Self { - let mut path: SymbolPath = value.scoped_identifier.as_ref().into(); - for x in &value.expression_identifier_list0 { - path.push(x.identifier.identifier_token.token.text); - } - path - } -} - -#[derive(Clone, Default, Debug)] -pub struct SymbolPathNamespace(pub SymbolPath, pub Namespace); - -impl From<&Token> for SymbolPathNamespace { - fn from(value: &Token) -> Self { - let namespace = namespace_table::get(value.id).unwrap(); - SymbolPathNamespace(value.into(), namespace) - } -} - -impl From<&SymbolPathNamespace> for SymbolPathNamespace { - fn from(value: &SymbolPathNamespace) -> Self { - value.clone() - } -} - -impl From<(&SymbolPath, &Namespace)> for SymbolPathNamespace { - fn from(value: (&SymbolPath, &Namespace)) -> Self { - SymbolPathNamespace(value.0.clone(), value.1.clone()) - } -} - -impl From<(&Token, &Namespace)> for SymbolPathNamespace { - fn from(value: (&Token, &Namespace)) -> Self { - let path = SymbolPath::new(&[value.0.text]); - SymbolPathNamespace(path, value.1.clone()) - } -} - -impl From<(&Vec, &Namespace)> for SymbolPathNamespace { - fn from(value: (&Vec, &Namespace)) -> Self { - let path = SymbolPath::new(value.0); - SymbolPathNamespace(path, value.1.clone()) - } -} - -impl From<&syntax_tree::Identifier> for SymbolPathNamespace { - fn from(value: &syntax_tree::Identifier) -> Self { - let namespace = namespace_table::get(value.identifier_token.token.id).unwrap(); - SymbolPathNamespace(value.into(), namespace) - } -} - -impl From<&[syntax_tree::Identifier]> for SymbolPathNamespace { - fn from(value: &[syntax_tree::Identifier]) -> Self { - let namespace = namespace_table::get(value[0].identifier_token.token.id).unwrap(); - SymbolPathNamespace(value.into(), namespace) - } -} - -impl From<&syntax_tree::HierarchicalIdentifier> for SymbolPathNamespace { - fn from(value: &syntax_tree::HierarchicalIdentifier) -> Self { - let namespace = namespace_table::get(value.identifier.identifier_token.token.id).unwrap(); - SymbolPathNamespace(value.into(), namespace) - } -} - -impl From<&syntax_tree::ScopedIdentifier> for SymbolPathNamespace { - fn from(value: &syntax_tree::ScopedIdentifier) -> Self { - let namespace = namespace_table::get(value.identifier().token.id).unwrap(); - SymbolPathNamespace(value.into(), namespace) - } -} - -impl From<&syntax_tree::ExpressionIdentifier> for SymbolPathNamespace { - fn from(value: &syntax_tree::ExpressionIdentifier) -> Self { - let namespace = namespace_table::get(value.identifier().token.id).unwrap(); - SymbolPathNamespace(value.into(), namespace) - } -} - #[derive(Clone, Debug)] pub struct ResolveResult { pub found: Symbol, @@ -404,6 +227,18 @@ impl SymbolTable { } context.inner = true; } + SymbolKind::GenericInstance(ref x) => { + let symbol = self.symbol_table.get(&x.base).unwrap(); + context.namespace = symbol.inner_namespace(); + context.inner = true; + context + .generic_namespace_map + .insert(symbol.token.text, found.token.text); + } + SymbolKind::GenericParameter => { + context.namespace = found.inner_namespace(); + context.inner = true; + } // don't trace inner item SymbolKind::Function(_) | SymbolKind::Struct(_) @@ -429,8 +264,14 @@ impl SymbolTable { } } if let Some(found) = context.found { + let mut found = found.clone(); + + // replace namespace path to generic version + let generic_namespace = found.namespace.replace(&context.generic_namespace_map); + found.namespace = generic_namespace; + Ok(ResolveResult { - found: found.clone(), + found, full_path: context.full_path, }) } else { @@ -508,6 +349,16 @@ impl SymbolTable { for (_, symbol) in self.symbol_table.iter_mut() { if symbol.id == target { symbol.references.push(token.to_owned()); + break; + } + } + } + + pub fn add_generic_instance(&mut self, target: SymbolId, instance: SymbolId) { + for (_, symbol) in self.symbol_table.iter_mut() { + if symbol.id == target && !symbol.generic_instances.contains(&instance) { + symbol.generic_instances.push(instance); + break; } } } @@ -620,6 +471,7 @@ struct ResolveContext<'a> { last_found: Option<&'a Symbol>, full_path: Vec, namespace: Namespace, + generic_namespace_map: HashMap, inner: bool, other_prj: bool, sv_member: bool, @@ -632,6 +484,7 @@ impl<'a> ResolveContext<'a> { last_found: None, full_path: vec![], namespace: namespace.clone(), + generic_namespace_map: HashMap::new(), inner: false, other_prj: false, sv_member: false, @@ -876,6 +729,10 @@ pub fn add_reference(target: SymbolId, token: &Token) { SYMBOL_TABLE.with(|f| f.borrow_mut().add_reference(target, token)) } +pub fn add_generic_instance(target: SymbolId, instance: SymbolId) { + SYMBOL_TABLE.with(|f| f.borrow_mut().add_generic_instance(target, instance)) +} + pub fn add_imported_item(target: TokenId, namespace: &Namespace) { SYMBOL_TABLE.with(|f| f.borrow_mut().add_imported_item(target, namespace)) } diff --git a/crates/analyzer/src/tests.rs b/crates/analyzer/src/tests.rs index db16f3e4..1e949066 100644 --- a/crates/analyzer/src/tests.rs +++ b/crates/analyzer/src/tests.rs @@ -574,7 +574,7 @@ fn invalid_statement() { } #[test] -fn mismatch_arity() { +fn mismatch_function_arity() { let code = r#" module ModuleA { function FuncA ( @@ -586,7 +586,45 @@ fn mismatch_arity() { "#; let errors = analyze(code); - assert!(matches!(errors[0], AnalyzerError::MismatchArity { .. })); + assert!(matches!( + errors[0], + AnalyzerError::MismatchFunctionArity { .. } + )); +} + +#[test] +fn mismatch_generics_arity() { + let code = r#" + module ModuleA { + function FuncA:: ( + a: input logic, + ) -> logic {} + + let _a: logic = FuncA::<1, 2>(1); + } + "#; + + let errors = analyze(code); + assert!(matches!( + errors[0], + AnalyzerError::MismatchGenericsArity { .. } + )); + + let code = r#" + module ModuleB { + function FuncA:: ( + a: input logic, + ) -> logic {} + + let _a: logic = FuncA::<1>(1); + } + "#; + + let errors = analyze(code); + assert!(matches!( + errors[0], + AnalyzerError::MismatchGenericsArity { .. } + )); } #[test] diff --git a/crates/analyzer/src/type_dag.rs b/crates/analyzer/src/type_dag.rs index b33da535..10e493d4 100644 --- a/crates/analyzer/src/type_dag.rs +++ b/crates/analyzer/src/type_dag.rs @@ -1,7 +1,6 @@ -use crate::{ - symbol::{Symbol, SymbolId}, - symbol_table::{self, SymbolPathNamespace}, -}; +use crate::symbol::{Symbol, SymbolId}; +use crate::symbol_path::SymbolPathNamespace; +use crate::symbol_table; use bimap::BiMap; use std::{cell::RefCell, collections::HashMap, collections::HashSet}; diff --git a/crates/emitter/src/aligner.rs b/crates/emitter/src/aligner.rs index 3d76b37e..4ee94b56 100644 --- a/crates/emitter/src/aligner.rs +++ b/crates/emitter/src/aligner.rs @@ -1,5 +1,6 @@ use crate::emitter::{symbol_string, SymbolContext}; use std::collections::HashMap; +use veryl_analyzer::symbol::GenericMap; use veryl_analyzer::symbol_table; use veryl_metadata::{Build, BuiltinType, Metadata}; use veryl_parser::resource_table::StrId; @@ -135,6 +136,7 @@ pub struct Aligner { in_import: bool, project_name: Option, build_opt: Build, + generic_map: GenericMap, } impl Aligner { @@ -880,10 +882,10 @@ impl VerylWalker for Aligner { fn function_declaration(&mut self, arg: &FunctionDeclaration) { self.function(&arg.function); self.identifier(&arg.identifier); - if let Some(ref x) = arg.function_declaration_opt { + if let Some(ref x) = arg.function_declaration_opt0 { self.port_declaration(&x.port_declaration); } - if let Some(ref x) = arg.function_declaration_opt0 { + if let Some(ref x) = arg.function_declaration_opt1 { self.minus_g_t(&x.minus_g_t); self.scalar_type(&x.scalar_type); self.reset_align(); @@ -915,6 +917,7 @@ impl From<&mut Aligner> for SymbolContext { project_name: value.project_name, build_opt: value.build_opt.clone(), in_import: value.in_import, + generic_map: value.generic_map.clone(), } } } diff --git a/crates/emitter/src/emitter.rs b/crates/emitter/src/emitter.rs index fa8a888b..0a655e16 100644 --- a/crates/emitter/src/emitter.rs +++ b/crates/emitter/src/emitter.rs @@ -4,8 +4,9 @@ use veryl_analyzer::attribute::Attribute as Attr; use veryl_analyzer::attribute_table; use veryl_analyzer::namespace::Namespace; use veryl_analyzer::symbol::TypeModifier as SymTypeModifier; -use veryl_analyzer::symbol::{Symbol, SymbolKind, TypeKind}; -use veryl_analyzer::symbol_table::{self, SymbolPath}; +use veryl_analyzer::symbol::{GenericMap, Symbol, SymbolKind, TypeKind}; +use veryl_analyzer::symbol_path::{GenericSymbolPath, SymbolPath}; +use veryl_analyzer::symbol_table; use veryl_analyzer::{msb_table, namespace_table}; use veryl_metadata::{Build, BuiltinType, ClockType, Format, Metadata, ResetType}; use veryl_parser::resource_table::{self, StrId}; @@ -49,6 +50,7 @@ pub struct Emitter { file_scope_import: Vec, attribute: Vec, assignment_lefthand_side: Option, + generic_map: GenericMap, } impl Default for Emitter { @@ -77,6 +79,7 @@ impl Default for Emitter { file_scope_import: Vec::new(), attribute: Vec::new(), assignment_lefthand_side: None, + generic_map: GenericMap::default(), } } } @@ -554,10 +557,17 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'ScopedIdentifier' fn scoped_identifier(&mut self, arg: &ScopedIdentifier) { - if let Ok(symbol) = symbol_table::resolve(arg) { + let mut path: GenericSymbolPath = arg.into(); + path.apply_map(&self.generic_map.map); + let namespace = namespace_table::get(arg.identifier().token.id).unwrap(); + if let Ok(symbol) = symbol_table::resolve((&path.mangled_path(), &namespace)) { let context: SymbolContext = self.into(); let text = symbol_string(arg.identifier(), &symbol.found, &context); self.veryl_token(&arg.identifier().replace(&text)); + } else if !path.resolvable { + // emit literal by generics + let text = path.base_path(0).0[0].to_string(); + self.veryl_token(&arg.identifier().replace(&text)); } } @@ -1850,24 +1860,38 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'StructUnionDeclaration' fn struct_union_declaration(&mut self, arg: &StructUnionDeclaration) { - match &*arg.struct_union { - StructUnion::Struct(ref x) => { - self.token(&x.r#struct.struct_token.append("typedef ", " packed")); + let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); + let maps = symbol.found.generic_maps(); + + for (i, map) in maps.iter().enumerate() { + if i != 0 { + self.newline(); + } + self.generic_map = map.clone(); + + match &*arg.struct_union { + StructUnion::Struct(ref x) => { + self.token(&x.r#struct.struct_token.append("typedef ", " packed")); + } + StructUnion::Union(ref x) => { + self.token(&x.union.union_token.append("typedef ", " packed")); + } } - StructUnion::Union(ref x) => { - self.token(&x.union.union_token.append("typedef ", " packed")); + self.space(1); + self.token_will_push(&arg.l_brace.l_brace_token); + self.newline_push(); + self.struct_union_list(&arg.struct_union_list); + self.newline_pop(); + self.str("}"); + self.space(1); + if map.generic() { + self.str(&self.generic_map.name.clone()); + } else { + self.identifier(&arg.identifier); } + self.str(";"); + self.token(&arg.r_brace.r_brace_token.replace("")); } - self.space(1); - self.token_will_push(&arg.l_brace.l_brace_token); - self.newline_push(); - self.struct_union_list(&arg.struct_union_list); - self.newline_pop(); - self.str("}"); - self.space(1); - self.identifier(&arg.identifier); - self.str(";"); - self.token(&arg.r_brace.r_brace_token.replace("")); } /// Semantic action for non-terminal 'StructUnionList' @@ -2278,42 +2302,56 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'FunctionDeclaration' fn function_declaration(&mut self, arg: &FunctionDeclaration) { - self.function(&arg.function); - self.space(1); - self.str("automatic"); - self.space(1); - if let Some(ref x) = &arg.function_declaration_opt0 { - self.scalar_type(&x.scalar_type); - } else { - self.str("void"); - } - self.space(1); - self.identifier(&arg.identifier); - if let Some(ref x) = arg.function_declaration_opt { - self.port_declaration(&x.port_declaration); + let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); + let maps = symbol.found.generic_maps(); + + for (i, map) in maps.iter().enumerate() { + if i != 0 { + self.newline(); + } + self.generic_map = map.clone(); + + self.function(&arg.function); self.space(1); + self.str("automatic"); + self.space(1); + if let Some(ref x) = &arg.function_declaration_opt1 { + self.scalar_type(&x.scalar_type); + } else { + self.str("void"); + } + self.space(1); + if map.generic() { + self.str(&self.generic_map.name.clone()); + } else { + self.identifier(&arg.identifier); + } + if let Some(ref x) = arg.function_declaration_opt0 { + self.port_declaration(&x.port_declaration); + self.space(1); + } + if let Some(ref x) = arg.function_declaration_opt1 { + self.token(&x.minus_g_t.minus_g_t_token.replace("")); + } + self.str(";"); + self.token_will_push(&arg.l_brace.l_brace_token.replace("")); + let mut base = 0; + for (i, x) in arg + .function_declaration_list + .iter() + .filter(|x| is_func_let_statement(&x.function_item)) + .enumerate() + { + self.newline_list(i); + base += self.function_item_variable_declatation_only(&x.function_item); + } + for (i, x) in arg.function_declaration_list.iter().enumerate() { + self.newline_list(base + i); + self.function_item_statement_only(&x.function_item); + } + self.newline_list_post(arg.function_declaration_list.is_empty()); + self.token(&arg.r_brace.r_brace_token.replace("endfunction")); } - if let Some(ref x) = arg.function_declaration_opt0 { - self.token(&x.minus_g_t.minus_g_t_token.replace("")); - } - self.str(";"); - self.token_will_push(&arg.l_brace.l_brace_token.replace("")); - let mut base = 0; - for (i, x) in arg - .function_declaration_list - .iter() - .filter(|x| is_func_let_statement(&x.function_item)) - .enumerate() - { - self.newline_list(i); - base += self.function_item_variable_declatation_only(&x.function_item); - } - for (i, x) in arg.function_declaration_list.iter().enumerate() { - self.newline_list(base + i); - self.function_item_statement_only(&x.function_item); - } - self.newline_list_post(arg.function_declaration_list.is_empty()); - self.token(&arg.r_brace.r_brace_token.replace("endfunction")); } /// Semantic action for non-terminal 'ImportDeclaration' @@ -2349,41 +2387,55 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'ModuleDeclaration' fn module_declaration(&mut self, arg: &ModuleDeclaration) { - self.module(&arg.module); - self.space(1); - if let Ok(symbol) = symbol_table::resolve(arg.identifier.as_ref()) { - let context: SymbolContext = self.into(); - self.str(&namespace_string(&symbol.found.namespace, &context)); - } - self.identifier(&arg.identifier); - let file_scope_import = self.file_scope_import.clone(); - if !file_scope_import.is_empty() { - self.newline_push(); - } - for (i, x) in file_scope_import.iter().enumerate() { + let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); + let maps = symbol.found.generic_maps(); + + for (i, map) in maps.iter().enumerate() { if i != 0 { self.newline(); } - self.str(x); - } - if !file_scope_import.is_empty() { - self.newline_pop(); - } - if let Some(ref x) = arg.module_declaration_opt0 { - self.space(1); - self.with_parameter(&x.with_parameter); - } - if let Some(ref x) = arg.module_declaration_opt1 { + self.generic_map = map.clone(); + + self.module(&arg.module); self.space(1); - self.port_declaration(&x.port_declaration); - } - self.token_will_push(&arg.l_brace.l_brace_token.replace(";")); - for (i, x) in arg.module_declaration_list.iter().enumerate() { - self.newline_list(i); - self.module_group(&x.module_group); + if map.generic() { + self.str(&self.generic_map.name.clone()); + } else { + if let Ok(symbol) = symbol_table::resolve(arg.identifier.as_ref()) { + let context: SymbolContext = self.into(); + self.str(&namespace_string(&symbol.found.namespace, &context)); + } + self.identifier(&arg.identifier); + } + let file_scope_import = self.file_scope_import.clone(); + if !file_scope_import.is_empty() { + self.newline_push(); + } + for (i, x) in file_scope_import.iter().enumerate() { + if i != 0 { + self.newline(); + } + self.str(x); + } + if !file_scope_import.is_empty() { + self.newline_pop(); + } + if let Some(ref x) = arg.module_declaration_opt1 { + self.space(1); + self.with_parameter(&x.with_parameter); + } + if let Some(ref x) = arg.module_declaration_opt2 { + self.space(1); + self.port_declaration(&x.port_declaration); + } + self.token_will_push(&arg.l_brace.l_brace_token.replace(";")); + for (i, x) in arg.module_declaration_list.iter().enumerate() { + self.newline_list(i); + self.module_group(&x.module_group); + } + self.newline_list_post(arg.module_declaration_list.is_empty()); + self.token(&arg.r_brace.r_brace_token.replace("endmodule")); } - self.newline_list_post(arg.module_declaration_list.is_empty()); - self.token(&arg.r_brace.r_brace_token.replace("endmodule")); } /// Semantic action for non-terminal 'ModuleIfDeclaration' @@ -2533,37 +2585,51 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'InterfaceDeclaration' fn interface_declaration(&mut self, arg: &InterfaceDeclaration) { - self.interface(&arg.interface); - self.space(1); - if let Ok(symbol) = symbol_table::resolve(arg.identifier.as_ref()) { - let context: SymbolContext = self.into(); - self.str(&namespace_string(&symbol.found.namespace, &context)); - } - self.identifier(&arg.identifier); - let file_scope_import = self.file_scope_import.clone(); - if !file_scope_import.is_empty() { - self.newline_push(); - } - for (i, x) in file_scope_import.iter().enumerate() { + let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); + let maps = symbol.found.generic_maps(); + + for (i, map) in maps.iter().enumerate() { if i != 0 { self.newline(); } - self.str(x); - } - if !file_scope_import.is_empty() { - self.newline_pop(); - } - if let Some(ref x) = arg.interface_declaration_opt0 { + self.generic_map = map.clone(); + + self.interface(&arg.interface); self.space(1); - self.with_parameter(&x.with_parameter); - } - self.token_will_push(&arg.l_brace.l_brace_token.replace(";")); - for (i, x) in arg.interface_declaration_list.iter().enumerate() { - self.newline_list(i); - self.interface_group(&x.interface_group); + if map.generic() { + self.str(&self.generic_map.name.clone()); + } else { + if let Ok(symbol) = symbol_table::resolve(arg.identifier.as_ref()) { + let context: SymbolContext = self.into(); + self.str(&namespace_string(&symbol.found.namespace, &context)); + } + self.identifier(&arg.identifier); + } + let file_scope_import = self.file_scope_import.clone(); + if !file_scope_import.is_empty() { + self.newline_push(); + } + for (i, x) in file_scope_import.iter().enumerate() { + if i != 0 { + self.newline(); + } + self.str(x); + } + if !file_scope_import.is_empty() { + self.newline_pop(); + } + if let Some(ref x) = arg.interface_declaration_opt1 { + self.space(1); + self.with_parameter(&x.with_parameter); + } + self.token_will_push(&arg.l_brace.l_brace_token.replace(";")); + for (i, x) in arg.interface_declaration_list.iter().enumerate() { + self.newline_list(i); + self.interface_group(&x.interface_group); + } + self.newline_list_post(arg.interface_declaration_list.is_empty()); + self.token(&arg.r_brace.r_brace_token.replace("endinterface")); } - self.newline_list_post(arg.interface_declaration_list.is_empty()); - self.token(&arg.r_brace.r_brace_token.replace("endinterface")); } /// Semantic action for non-terminal 'InterfaceIfDeclaration' @@ -2713,27 +2779,41 @@ impl VerylWalker for Emitter { /// Semantic action for non-terminal 'PackageDeclaration' fn package_declaration(&mut self, arg: &PackageDeclaration) { - self.package(&arg.package); - self.space(1); - if let Ok(symbol) = symbol_table::resolve(arg.identifier.as_ref()) { - let context: SymbolContext = self.into(); - self.str(&namespace_string(&symbol.found.namespace, &context)); - } - self.identifier(&arg.identifier); - self.token_will_push(&arg.l_brace.l_brace_token.replace(";")); - for (i, x) in arg.package_declaration_list.iter().enumerate() { - self.newline_list(i); - if i == 0 { - let file_scope_import = self.file_scope_import.clone(); - for x in &file_scope_import { - self.str(x); - self.newline(); + let symbol = symbol_table::resolve(arg.identifier.as_ref()).unwrap(); + let maps = symbol.found.generic_maps(); + + for (i, map) in maps.iter().enumerate() { + if i != 0 { + self.newline(); + } + self.generic_map = map.clone(); + + self.package(&arg.package); + self.space(1); + if map.generic() { + self.str(&self.generic_map.name.clone()); + } else { + if let Ok(symbol) = symbol_table::resolve(arg.identifier.as_ref()) { + let context: SymbolContext = self.into(); + self.str(&namespace_string(&symbol.found.namespace, &context)); } + self.identifier(&arg.identifier); } - self.package_group(&x.package_group); + self.token_will_push(&arg.l_brace.l_brace_token.replace(";")); + for (i, x) in arg.package_declaration_list.iter().enumerate() { + self.newline_list(i); + if i == 0 { + let file_scope_import = self.file_scope_import.clone(); + for x in &file_scope_import { + self.str(x); + self.newline(); + } + } + self.package_group(&x.package_group); + } + self.newline_list_post(arg.package_declaration_list.is_empty()); + self.token(&arg.r_brace.r_brace_token.replace("endpackage")); } - self.newline_list_post(arg.package_declaration_list.is_empty()); - self.token(&arg.r_brace.r_brace_token.replace("endpackage")); } /// Semantic action for non-terminal 'PackageGroup' @@ -2861,6 +2941,7 @@ pub struct SymbolContext { pub project_name: Option, pub build_opt: Build, pub in_import: bool, + pub generic_map: GenericMap, } impl From<&mut Emitter> for SymbolContext { @@ -2869,6 +2950,7 @@ impl From<&mut Emitter> for SymbolContext { project_name: value.project_name, build_opt: value.build_opt.clone(), in_import: value.in_import, + generic_map: value.generic_map.clone(), } } } @@ -2901,6 +2983,7 @@ fn namespace_string(namespace: &Namespace, context: &SymbolContext) -> String { if let Ok(ref symbol) = symbol_table::resolve((&symbol_path, &resolve_namespace)) { let separator = match symbol.found.kind { SymbolKind::Package(_) => "::", + SymbolKind::GenericInstance(_) => "::", SymbolKind::Interface(_) => ".", _ if in_sv_namespace => "::", _ => "_", @@ -2958,6 +3041,39 @@ pub fn symbol_string(token: &VerylToken, symbol: &Symbol, context: &SymbolContex ret.push_str(&namespace_string(&symbol.namespace, context)); ret.push_str(&symbol.token.to_string()); } + //SymbolKind::GenericParameter => { + // if let Some(generic_arg) = context.generic_map.get(&symbol.token.text) { + // let path = generic_arg.base_path(); + + // let emit_namespace = match symbol_table::resolve((&path, &namespace)) { + // Ok(symbol) => matches!( + // symbol.found.kind, + // SymbolKind::Module(_) | SymbolKind::Interface(_) | SymbolKind::Package(_) + // ), + // Err(_) => true, + // }; + + // if emit_namespace { + // if let Ok(symbol) = symbol_table::resolve((&path, &symbol.namespace)) { + // ret.push_str(&namespace_string(&symbol.found.namespace, context)); + // } + // } + // ret.push_str(&generic_arg.to_string()); + // } + //} + SymbolKind::GenericInstance(x) => { + let base = symbol_table::get(x.base).unwrap(); + let visible = symbol_table::resolve((&symbol.token, &namespace)).is_ok(); + let top_level = matches!( + base.kind, + SymbolKind::Module(_) | SymbolKind::Interface(_) | SymbolKind::Package(_) + ); + if !visible | top_level { + ret.push_str(&namespace_string(&base.namespace, context)); + } + ret.push_str(&symbol.token.to_string()); + } + SymbolKind::GenericParameter => (), SymbolKind::Port(_) | SymbolKind::Variable(_) | SymbolKind::Instance(_) diff --git a/crates/formatter/src/aligner.rs b/crates/formatter/src/aligner.rs index 5c280132..c5ad3e02 100644 --- a/crates/formatter/src/aligner.rs +++ b/crates/formatter/src/aligner.rs @@ -778,9 +778,12 @@ impl VerylWalker for Aligner { self.function(&arg.function); self.identifier(&arg.identifier); if let Some(ref x) = arg.function_declaration_opt { - self.port_declaration(&x.port_declaration); + self.with_generic_parameter(&x.with_generic_parameter); } if let Some(ref x) = arg.function_declaration_opt0 { + self.port_declaration(&x.port_declaration); + } + if let Some(ref x) = arg.function_declaration_opt1 { self.minus_g_t(&x.minus_g_t); self.scalar_type(&x.scalar_type); self.reset_align(); diff --git a/crates/formatter/src/formatter.rs b/crates/formatter/src/formatter.rs index e189595a..a69afa34 100644 --- a/crates/formatter/src/formatter.rs +++ b/crates/formatter/src/formatter.rs @@ -1049,6 +1049,9 @@ impl VerylWalker for Formatter { self.struct_union(&arg.struct_union); self.space(1); self.identifier(&arg.identifier); + if let Some(ref x) = arg.struct_union_declaration_opt { + self.with_generic_parameter(&x.with_generic_parameter); + } self.space(1); self.token_will_push(&arg.l_brace.l_brace_token); self.newline_push(); @@ -1348,6 +1351,32 @@ impl VerylWalker for Formatter { } } + /// Semantic action for non-terminal 'WithGenericParameterList' + fn with_generic_parameter_list(&mut self, arg: &WithGenericParameterList) { + self.with_generic_parameter_item(&arg.with_generic_parameter_item); + for x in &arg.with_generic_parameter_list_list { + self.comma(&x.comma); + self.space(1); + self.with_generic_parameter_item(&x.with_generic_parameter_item); + } + if let Some(ref x) = arg.with_generic_parameter_list_opt { + self.comma(&x.comma); + } + } + + /// Semantic action for non-terminal 'WithGenericArgumentList' + fn with_generic_argument_list(&mut self, arg: &WithGenericArgumentList) { + self.with_generic_argument_item(&arg.with_generic_argument_item); + for x in &arg.with_generic_argument_list_list { + self.comma(&x.comma); + self.space(1); + self.with_generic_argument_item(&x.with_generic_argument_item); + } + if let Some(ref x) = arg.with_generic_argument_list_opt { + self.comma(&x.comma); + } + } + /// Semantic action for non-terminal 'PortDeclaration' fn port_declaration(&mut self, arg: &PortDeclaration) { if let Some(ref x) = arg.port_declaration_opt { @@ -1423,12 +1452,15 @@ impl VerylWalker for Formatter { self.function(&arg.function); self.space(1); self.identifier(&arg.identifier); - self.space(1); if let Some(ref x) = arg.function_declaration_opt { + self.with_generic_parameter(&x.with_generic_parameter); + } + self.space(1); + if let Some(ref x) = arg.function_declaration_opt0 { self.port_declaration(&x.port_declaration); self.space(1); } - if let Some(ref x) = arg.function_declaration_opt0 { + if let Some(ref x) = arg.function_declaration_opt1 { self.minus_g_t(&x.minus_g_t); self.space(1); self.scalar_type(&x.scalar_type); @@ -1481,12 +1513,15 @@ impl VerylWalker for Formatter { self.module(&arg.module); self.space(1); self.identifier(&arg.identifier); - self.space(1); if let Some(ref x) = arg.module_declaration_opt0 { + self.with_generic_parameter(&x.with_generic_parameter); + } + self.space(1); + if let Some(ref x) = arg.module_declaration_opt1 { self.with_parameter(&x.with_parameter); self.space(1); } - if let Some(ref x) = arg.module_declaration_opt1 { + if let Some(ref x) = arg.module_declaration_opt2 { self.port_declaration(&x.port_declaration); self.space(1); } @@ -1604,8 +1639,11 @@ impl VerylWalker for Formatter { self.interface(&arg.interface); self.space(1); self.identifier(&arg.identifier); - self.space(1); if let Some(ref x) = arg.interface_declaration_opt0 { + self.with_generic_parameter(&x.with_generic_parameter); + } + self.space(1); + if let Some(ref x) = arg.interface_declaration_opt1 { self.with_parameter(&x.with_parameter); self.space(1); } @@ -1724,6 +1762,9 @@ impl VerylWalker for Formatter { self.package(&arg.package); self.space(1); self.identifier(&arg.identifier); + if let Some(ref x) = arg.package_declaration_opt0 { + self.with_generic_parameter(&x.with_generic_parameter); + } self.space(1); self.token_will_push(&arg.l_brace.l_brace_token); for (i, x) in arg.package_declaration_list.iter().enumerate() { diff --git a/crates/languageserver/build.rs b/crates/languageserver/build.rs index 5e4ea526..6dcf425c 100644 --- a/crates/languageserver/build.rs +++ b/crates/languageserver/build.rs @@ -10,24 +10,21 @@ fn main() { } } + println!("cargo::rerun-if-changed=../parser/veryl.par"); + let par_file = PathBuf::from("../parser/veryl.par"); let exp_file = PathBuf::from("src/keyword.rs"); - let par_modified = fs::metadata(&par_file).unwrap().modified().unwrap(); - let exp_modified = fs::metadata(&exp_file).unwrap().modified().unwrap(); - - if par_modified > exp_modified { - let text = fs::read_to_string(&par_file).unwrap(); - let mut keywords = "pub const KEYWORDS: &[&str] = &[\n".to_string(); - for line in text.lines() { - if line.contains("(?-u:\\b)") { - let keyword = line.split_ascii_whitespace().nth(2).unwrap(); - let keyword = keyword.replace("/(?-u:\\b)", ""); - let keyword = keyword.replace("(?-u:\\b)/", ""); - keywords.push_str(&format!(" \"{keyword}\",\n")); - } + let text = fs::read_to_string(par_file).unwrap(); + let mut keywords = "pub const KEYWORDS: &[&str] = &[\n".to_string(); + for line in text.lines() { + if line.contains("(?-u:\\b)") { + let keyword = line.split('/').nth(1).unwrap(); + let keyword = keyword.replace("(?-u:\\b)", ""); + let keyword = keyword.replace("(?-u:\\b)", ""); + keywords.push_str(&format!(" \"{keyword}\",\n")); } - keywords.push_str("];\n"); - fs::write(&exp_file, keywords).unwrap(); } + keywords.push_str("];\n"); + fs::write(exp_file, keywords).unwrap(); } diff --git a/crates/languageserver/src/server.rs b/crates/languageserver/src/server.rs index a3ff018d..42b9f3b3 100644 --- a/crates/languageserver/src/server.rs +++ b/crates/languageserver/src/server.rs @@ -9,7 +9,7 @@ use tower_lsp::lsp_types::*; use tower_lsp::Client; use veryl_analyzer::namespace::Namespace; use veryl_analyzer::symbol::SymbolKind as VerylSymbolKind; -use veryl_analyzer::symbol_table::SymbolPath; +use veryl_analyzer::symbol_path::SymbolPath; use veryl_analyzer::{namespace_table, symbol_table, Analyzer, AnalyzerError}; use veryl_formatter::Formatter; use veryl_metadata::{Metadata, PathPair}; @@ -328,6 +328,8 @@ impl Server { VerylSymbolKind::SystemVerilog => SymbolKind::NAMESPACE, VerylSymbolKind::Namespace => SymbolKind::NAMESPACE, VerylSymbolKind::SystemFunction => SymbolKind::FUNCTION, + VerylSymbolKind::GenericParameter => SymbolKind::TYPE_PARAMETER, + VerylSymbolKind::GenericInstance(_) => SymbolKind::MODULE, }; let location = to_location(&symbol.token); #[allow(deprecated)] diff --git a/crates/parser/src/finder.rs b/crates/parser/src/finder.rs index 0c94c313..9fdf3af2 100644 --- a/crates/parser/src/finder.rs +++ b/crates/parser/src/finder.rs @@ -66,7 +66,12 @@ impl VerylWalker for Finder { self.group_hit = false; self.in_group = true; match &*arg.scoped_identifier_group { - ScopedIdentifierGroup::Identifier(x) => self.identifier(&x.identifier), + ScopedIdentifierGroup::IdentifierScopedIdentifierOpt(x) => { + self.identifier(&x.identifier); + if let Some(ref x) = x.scoped_identifier_opt { + self.with_generic_argument(&x.with_generic_argument); + } + } ScopedIdentifierGroup::DollarIdentifier(x) => { self.dollar_identifier(&x.dollar_identifier) } @@ -77,6 +82,9 @@ impl VerylWalker for Finder { self.in_group = true; self.identifier(&x.identifier); self.in_group = false; + if let Some(ref x) = x.scoped_identifier_opt0 { + self.with_generic_argument(&x.with_generic_argument); + } } if self.group_hit { self.lock_group = true; @@ -91,7 +99,12 @@ impl VerylWalker for Finder { self.group_hit = false; self.in_group = true; match &*x.scoped_identifier_group { - ScopedIdentifierGroup::Identifier(x) => self.identifier(&x.identifier), + ScopedIdentifierGroup::IdentifierScopedIdentifierOpt(x) => { + self.identifier(&x.identifier); + if let Some(ref x) = x.scoped_identifier_opt { + self.with_generic_argument(&x.with_generic_argument); + } + } ScopedIdentifierGroup::DollarIdentifier(x) => { self.dollar_identifier(&x.dollar_identifier) } @@ -102,6 +115,9 @@ impl VerylWalker for Finder { self.in_group = true; self.identifier(&x.identifier); self.in_group = false; + if let Some(ref x) = x.scoped_identifier_opt0 { + self.with_generic_argument(&x.with_generic_argument); + } } for x in &arg.expression_identifier_list { self.select(&x.select); diff --git a/crates/parser/src/generated/veryl-exp.par b/crates/parser/src/generated/veryl-exp.par index 0fa43f7a..f2810a80 100644 --- a/crates/parser/src/generated/veryl-exp.par +++ b/crates/parser/src/generated/veryl-exp.par @@ -5,16 +5,17 @@ %user_type VerylToken = crate::veryl_token::VerylToken %scanner Embed { %auto_newline_off %auto_ws_off } +%scanner Generic { } %% -/* 0 */ CommentsTerm: "(?:(?:(?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))\s*)+" : Token; -/* 1 */ StringLiteralTerm: "\u{0022}(?:\\[\u{0022}\\/bfnrt]|u[0-9a-fA-F]{4}|[^\u{0022}\\\u0000-\u001F])*\u{0022}" : Token; -/* 2 */ ExponentTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*[eE][+-]?[0-9]+(?:_[0-9]+)*/ : Token; -/* 3 */ FixedPointTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*/ : Token; -/* 4 */ BasedTerm: /(?:[0-9]+(?:_[0-9]+)*)?'[bodh][0-9a-fA-FxzXZ]+(?:_[0-9a-fA-FxzXZ]+)*/ : Token; -/* 5 */ AllBitTerm: /(?:[0-9]+(?:_[0-9]+)*)?'[01xzXZ]/ : Token; -/* 6 */ BaseLessTerm: /[0-9]+(?:_[0-9]+)*/ : Token; +/* 0 */ CommentsTerm: "(?:(?:(?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))\s*)+" : Token; +/* 1 */ StringLiteralTerm: "\u{0022}(?:\\[\u{0022}\\/bfnrt]|u[0-9a-fA-F]{4}|[^\u{0022}\\\u0000-\u001F])*\u{0022}" : Token; +/* 2 */ ExponentTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*[eE][+-]?[0-9]+(?:_[0-9]+)*/ : Token; +/* 3 */ FixedPointTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*/ : Token; +/* 4 */ BasedTerm: /(?:[0-9]+(?:_[0-9]+)*)?'[bodh][0-9a-fA-FxzXZ]+(?:_[0-9a-fA-FxzXZ]+)*/ : Token; +/* 5 */ AllBitTerm: /(?:[0-9]+(?:_[0-9]+)*)?'[01xzXZ]/ : Token; +/* 6 */ BaseLessTerm: /[0-9]+(?:_[0-9]+)*/ : Token; /* 7 */ MinusColonTerm: '-:' : Token; /* 8 */ MinusGTTerm: '->' : Token; /* 9 */ PlusColonTerm: '+:' : Token; @@ -31,856 +32,888 @@ /* 20 */ Operator04Term: "\^~|\^|~\^" : Token; /* 21 */ Operator03Term: "\|" : Token; /* 22 */ UnaryOperatorTerm: "~&|~\||!|~" : Token; -/* 23 */ ColonColonTerm: '::' : Token; -/* 24 */ ColonTerm: ':' : Token; -/* 25 */ CommaTerm: ',' : Token; -/* 26 */ DotDotEquTerm: '..=' : Token; -/* 27 */ DotDotTerm: '..' : Token; -/* 28 */ DotTerm: '.' : Token; -/* 29 */ EquTerm: '=' : Token; -/* 30 */ HashTerm: '#' : Token; -/* 31 */ LAngleTerm: '<' : Token; -/* 32 */ QuoteLBraceTerm: "'\{" : Token; -/* 33 */ LBraceTerm: '{' : Token; -/* 34 */ LBracketTerm: '[' : Token; -/* 35 */ LParenTerm: '(' : Token; -/* 36 */ RAngleTerm: '>' : Token; -/* 37 */ RBraceTerm: '}' : Token; -/* 38 */ RBracketTerm: ']' : Token; -/* 39 */ RParenTerm: ')' : Token; -/* 40 */ SemicolonTerm: ';' : Token; -/* 41 */ StarTerm: '*' : Token; -/* 42 */ AlwaysCombTerm: /(?-u:\b)always_comb(?-u:\b)/ : Token; -/* 43 */ AlwaysFfTerm: /(?-u:\b)always_ff(?-u:\b)/ : Token; -/* 44 */ AssignTerm: /(?-u:\b)assign(?-u:\b)/ : Token; -/* 45 */ AsTerm: /(?-u:\b)as(?-u:\b)/ : Token; -/* 46 */ BitTerm: /(?-u:\b)bit(?-u:\b)/ : Token; -/* 47 */ CaseTerm: /(?-u:\b)case(?-u:\b)/ : Token; -/* 48 */ ClockTerm: /(?-u:\b)clock(?-u:\b)/ : Token; -/* 49 */ ClockPosedgeTerm: /(?-u:\b)clock_posedge(?-u:\b)/ : Token; -/* 50 */ ClockNegedgeTerm: /(?-u:\b)clock_negedge(?-u:\b)/ : Token; -/* 51 */ DefaultTerm: /(?-u:\b)default(?-u:\b)/ : Token; -/* 52 */ ElseTerm: /(?-u:\b)else(?-u:\b)/ : Token; -/* 53 */ EmbedTerm: /(?-u:\b)embed(?-u:\b)/ : Token; -/* 54 */ EnumTerm: /(?-u:\b)enum(?-u:\b)/ : Token; -/* 55 */ ExportTerm: /(?-u:\b)export(?-u:\b)/ : Token; -/* 56 */ F32Term: /(?-u:\b)f32(?-u:\b)/ : Token; -/* 57 */ F64Term: /(?-u:\b)f64(?-u:\b)/ : Token; -/* 58 */ FinalTerm: /(?-u:\b)final(?-u:\b)/ : Token; -/* 59 */ ForTerm: /(?-u:\b)for(?-u:\b)/ : Token; -/* 60 */ FunctionTerm: /(?-u:\b)function(?-u:\b)/ : Token; -/* 61 */ I32Term: /(?-u:\b)i32(?-u:\b)/ : Token; -/* 62 */ I64Term: /(?-u:\b)i64(?-u:\b)/ : Token; -/* 63 */ IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/ : Token; -/* 64 */ IfTerm: /(?-u:\b)if(?-u:\b)/ : Token; -/* 65 */ ImportTerm: /(?-u:\b)import(?-u:\b)/ : Token; -/* 66 */ IncludeTerm: /(?-u:\b)include(?-u:\b)/ : Token; -/* 67 */ InitialTerm: /(?-u:\b)initial(?-u:\b)/ : Token; -/* 68 */ InoutTerm: /(?-u:\b)inout(?-u:\b)/ : Token; -/* 69 */ InputTerm: /(?-u:\b)input(?-u:\b)/ : Token; -/* 70 */ InsideTerm: /(?-u:\b)inside(?-u:\b)/ : Token; -/* 71 */ InstTerm: /(?-u:\b)inst(?-u:\b)/ : Token; -/* 72 */ InterfaceTerm: /(?-u:\b)interface(?-u:\b)/ : Token; -/* 73 */ InTerm: /(?-u:\b)in(?-u:\b)/ : Token; -/* 74 */ LetTerm: /(?-u:\b)let(?-u:\b)/ : Token; -/* 75 */ LocalTerm: /(?-u:\b)local(?-u:\b)/ : Token; -/* 76 */ LogicTerm: /(?-u:\b)logic(?-u:\b)/ : Token; -/* 77 */ LsbTerm: /(?-u:\b)lsb(?-u:\b)/ : Token; -/* 78 */ ModportTerm: /(?-u:\b)modport(?-u:\b)/ : Token; -/* 79 */ ModuleTerm: /(?-u:\b)module(?-u:\b)/ : Token; -/* 80 */ MsbTerm: /(?-u:\b)msb(?-u:\b)/ : Token; -/* 81 */ OutputTerm: /(?-u:\b)output(?-u:\b)/ : Token; -/* 82 */ OutsideTerm: /(?-u:\b)outside(?-u:\b)/ : Token; -/* 83 */ PackageTerm: /(?-u:\b)package(?-u:\b)/ : Token; -/* 84 */ ParamTerm: /(?-u:\b)param(?-u:\b)/ : Token; -/* 85 */ PubTerm: /(?-u:\b)pub(?-u:\b)/ : Token; -/* 86 */ RefTerm: /(?-u:\b)ref(?-u:\b)/ : Token; -/* 87 */ RepeatTerm: /(?-u:\b)repeat(?-u:\b)/ : Token; -/* 88 */ ResetTerm: /(?-u:\b)reset(?-u:\b)/ : Token; -/* 89 */ ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/ : Token; -/* 90 */ ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/ : Token; -/* 91 */ ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/ : Token; -/* 92 */ ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/ : Token; -/* 93 */ ReturnTerm: /(?-u:\b)return(?-u:\b)/ : Token; -/* 94 */ BreakTerm: /(?-u:\b)break(?-u:\b)/ : Token; -/* 95 */ SignedTerm: /(?-u:\b)signed(?-u:\b)/ : Token; -/* 96 */ StepTerm: /(?-u:\b)step(?-u:\b)/ : Token; -/* 97 */ StringTerm: /(?-u:\b)string(?-u:\b)/ : Token; -/* 98 */ StructTerm: /(?-u:\b)struct(?-u:\b)/ : Token; -/* 99 */ TriTerm: /(?-u:\b)tri(?-u:\b)/ : Token; -/* 100 */ TypeTerm: /(?-u:\b)type(?-u:\b)/ : Token; -/* 101 */ U32Term: /(?-u:\b)u32(?-u:\b)/ : Token; -/* 102 */ U64Term: /(?-u:\b)u64(?-u:\b)/ : Token; -/* 103 */ UnionTerm: /(?-u:\b)union(?-u:\b)/ : Token; -/* 104 */ VarTerm: /(?-u:\b)var(?-u:\b)/ : Token; -/* 105 */ DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; -/* 106 */ IdentifierTerm: /[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; -/* 107 */ AnyTerm: /[^{}]*/ : Token; -/* 108 */ Comments: CommentsOpt /* Option */; -/* 109 */ CommentsOpt /* Option::Some */: CommentsTerm; -/* 110 */ CommentsOpt /* Option::None */: ; -/* 111 */ StartToken: Comments; -/* 112 */ StringLiteralToken: StringLiteralTerm : Token Comments; -/* 113 */ ExponentToken: ExponentTerm : Token Comments; -/* 114 */ FixedPointToken: FixedPointTerm : Token Comments; -/* 115 */ BasedToken: BasedTerm : Token Comments; -/* 116 */ BaseLessToken: BaseLessTerm : Token Comments; -/* 117 */ AllBitToken: AllBitTerm : Token Comments; -/* 118 */ AssignmentOperatorToken: AssignmentOperatorTerm : Token Comments; -/* 119 */ Operator01Token: Operator01Term : Token Comments; -/* 120 */ Operator02Token: Operator02Term : Token Comments; -/* 121 */ Operator03Token: Operator03Term : Token Comments; -/* 122 */ Operator04Token: Operator04Term : Token Comments; -/* 123 */ Operator05Token: Operator05Term : Token Comments; -/* 124 */ Operator06Token: Operator06Term : Token Comments; -/* 125 */ Operator07Token: Operator07Term : Token Comments; -/* 126 */ Operator08Token: Operator08Term : Token Comments; -/* 127 */ Operator09Token: Operator09Term : Token Comments; -/* 128 */ Operator10Token: Operator10Term : Token Comments; -/* 129 */ Operator11Token: Operator11Term : Token Comments; -/* 130 */ UnaryOperatorToken: UnaryOperatorTerm : Token Comments; -/* 131 */ ColonToken: ColonTerm : Token Comments; -/* 132 */ ColonColonToken: ColonColonTerm : Token Comments; -/* 133 */ CommaToken: CommaTerm : Token Comments; -/* 134 */ DotDotToken: DotDotTerm : Token Comments; -/* 135 */ DotDotEquToken: DotDotEquTerm : Token Comments; -/* 136 */ DotToken: DotTerm : Token Comments; -/* 137 */ EquToken: EquTerm : Token Comments; -/* 138 */ HashToken: HashTerm : Token Comments; -/* 139 */ QuoteLBraceToken: QuoteLBraceTerm : Token Comments; -/* 140 */ LAngleToken: LAngleTerm : Token Comments; -/* 141 */ LBraceToken: LBraceTerm : Token Comments; -/* 142 */ LBracketToken: LBracketTerm : Token Comments; -/* 143 */ LParenToken: LParenTerm : Token Comments; -/* 144 */ MinusColonToken: MinusColonTerm : Token Comments; -/* 145 */ MinusGTToken: MinusGTTerm : Token Comments; -/* 146 */ PlusColonToken: PlusColonTerm : Token Comments; -/* 147 */ RAngleToken: RAngleTerm : Token Comments; -/* 148 */ RBraceToken: RBraceTerm : Token Comments; -/* 149 */ RBracketToken: RBracketTerm : Token Comments; -/* 150 */ RParenToken: RParenTerm : Token Comments; -/* 151 */ SemicolonToken: SemicolonTerm : Token Comments; -/* 152 */ StarToken: StarTerm : Token Comments; -/* 153 */ AlwaysCombToken: AlwaysCombTerm : Token Comments; -/* 154 */ AlwaysFfToken: AlwaysFfTerm : Token Comments; -/* 155 */ AsToken: AsTerm : Token Comments; -/* 156 */ AssignToken: AssignTerm : Token Comments; -/* 157 */ BitToken: BitTerm : Token Comments; -/* 158 */ CaseToken: CaseTerm : Token Comments; -/* 159 */ ClockToken: ClockTerm : Token Comments; -/* 160 */ ClockPosedgeToken: ClockPosedgeTerm : Token Comments; -/* 161 */ ClockNegedgeToken: ClockNegedgeTerm : Token Comments; -/* 162 */ DefaultToken: DefaultTerm : Token Comments; -/* 163 */ ElseToken: ElseTerm : Token Comments; -/* 164 */ EmbedToken: EmbedTerm : Token Comments; -/* 165 */ EnumToken: EnumTerm : Token Comments; -/* 166 */ ExportToken: ExportTerm : Token Comments; -/* 167 */ F32Token: F32Term : Token Comments; -/* 168 */ F64Token: F64Term : Token Comments; -/* 169 */ FinalToken: FinalTerm : Token Comments; -/* 170 */ ForToken: ForTerm : Token Comments; -/* 171 */ FunctionToken: FunctionTerm : Token Comments; -/* 172 */ I32Token: I32Term : Token Comments; -/* 173 */ I64Token: I64Term : Token Comments; -/* 174 */ IfResetToken: IfResetTerm : Token Comments; -/* 175 */ IfToken: IfTerm : Token Comments; -/* 176 */ ImportToken: ImportTerm : Token Comments; -/* 177 */ IncludeToken: IncludeTerm : Token Comments; -/* 178 */ InitialToken: InitialTerm : Token Comments; -/* 179 */ InoutToken: InoutTerm : Token Comments; -/* 180 */ InputToken: InputTerm : Token Comments; -/* 181 */ InsideToken: InsideTerm : Token Comments; -/* 182 */ InstToken: InstTerm : Token Comments; -/* 183 */ InterfaceToken: InterfaceTerm : Token Comments; -/* 184 */ InToken: InTerm : Token Comments; -/* 185 */ LetToken: LetTerm : Token Comments; -/* 186 */ LocalToken: LocalTerm : Token Comments; -/* 187 */ LogicToken: LogicTerm : Token Comments; -/* 188 */ LsbToken: LsbTerm : Token Comments; -/* 189 */ ModportToken: ModportTerm : Token Comments; -/* 190 */ ModuleToken: ModuleTerm : Token Comments; -/* 191 */ MsbToken: MsbTerm : Token Comments; -/* 192 */ OutputToken: OutputTerm : Token Comments; -/* 193 */ OutsideToken: OutsideTerm : Token Comments; -/* 194 */ PackageToken: PackageTerm : Token Comments; -/* 195 */ ParamToken: ParamTerm : Token Comments; -/* 196 */ PubToken: PubTerm : Token Comments; -/* 197 */ RefToken: RefTerm : Token Comments; -/* 198 */ RepeatToken: RepeatTerm : Token Comments; -/* 199 */ ResetToken: ResetTerm : Token Comments; -/* 200 */ ResetAsyncHighToken: ResetAsyncHighTerm : Token Comments; -/* 201 */ ResetAsyncLowToken: ResetAsyncLowTerm : Token Comments; -/* 202 */ ResetSyncHighToken: ResetSyncHighTerm : Token Comments; -/* 203 */ ResetSyncLowToken: ResetSyncLowTerm : Token Comments; -/* 204 */ ReturnToken: ReturnTerm : Token Comments; -/* 205 */ BreakToken: BreakTerm : Token Comments; -/* 206 */ SignedToken: SignedTerm : Token Comments; -/* 207 */ StepToken: StepTerm : Token Comments; -/* 208 */ StringToken: StringTerm : Token Comments; -/* 209 */ StructToken: StructTerm : Token Comments; -/* 210 */ TriToken: TriTerm : Token Comments; -/* 211 */ TypeToken: TypeTerm : Token Comments; -/* 212 */ U32Token: U32Term : Token Comments; -/* 213 */ U64Token: U64Term : Token Comments; -/* 214 */ UnionToken: UnionTerm : Token Comments; -/* 215 */ VarToken: VarTerm : Token Comments; -/* 216 */ DollarIdentifierToken: DollarIdentifierTerm : Token Comments; -/* 217 */ IdentifierToken: IdentifierTerm : Token Comments; -/* 218 */ Start: StartToken : VerylToken; -/* 219 */ StringLiteral: StringLiteralToken : VerylToken; -/* 220 */ Exponent: ExponentToken : VerylToken; -/* 221 */ FixedPoint: FixedPointToken : VerylToken; -/* 222 */ Based: BasedToken : VerylToken; -/* 223 */ BaseLess: BaseLessToken : VerylToken; -/* 224 */ AllBit: AllBitToken : VerylToken; -/* 225 */ AssignmentOperator: AssignmentOperatorToken : VerylToken; -/* 226 */ Operator01: Operator01Token : VerylToken; -/* 227 */ Operator02: Operator02Token : VerylToken; -/* 228 */ Operator03: Operator03Token : VerylToken; -/* 229 */ Operator04: Operator04Token : VerylToken; -/* 230 */ Operator05: Operator05Token : VerylToken; -/* 231 */ Operator06: Operator06Token : VerylToken; -/* 232 */ Operator07: Operator07Token : VerylToken; -/* 233 */ Operator08: Operator08Token : VerylToken; -/* 234 */ Operator09: Operator09Token : VerylToken; -/* 235 */ Operator10: Operator10Token : VerylToken; -/* 236 */ Operator11: Operator11Token : VerylToken; -/* 237 */ UnaryOperator: UnaryOperatorToken : VerylToken; -/* 238 */ Colon: ColonToken : VerylToken; -/* 239 */ ColonColon: ColonColonToken : VerylToken; -/* 240 */ Comma: CommaToken : VerylToken; -/* 241 */ DotDot: DotDotToken : VerylToken; -/* 242 */ DotDotEqu: DotDotEquToken : VerylToken; -/* 243 */ Dot: DotToken : VerylToken; -/* 244 */ Equ: EquToken : VerylToken; -/* 245 */ Hash: HashToken : VerylToken; -/* 246 */ QuoteLBrace: QuoteLBraceToken : VerylToken; -/* 247 */ LAngle: LAngleToken : VerylToken; -/* 248 */ LBrace: LBraceToken : VerylToken; -/* 249 */ LBracket: LBracketToken : VerylToken; -/* 250 */ LParen: LParenToken : VerylToken; -/* 251 */ MinusColon: MinusColonToken : VerylToken; -/* 252 */ MinusGT: MinusGTToken : VerylToken; -/* 253 */ PlusColon: PlusColonToken : VerylToken; -/* 254 */ RAngle: RAngleToken : VerylToken; -/* 255 */ RBrace: RBraceToken : VerylToken; -/* 256 */ RBracket: RBracketToken : VerylToken; -/* 257 */ RParen: RParenToken : VerylToken; -/* 258 */ Semicolon: SemicolonToken : VerylToken; -/* 259 */ Star: StarToken : VerylToken; -/* 260 */ AlwaysComb: AlwaysCombToken : VerylToken; -/* 261 */ AlwaysFf: AlwaysFfToken : VerylToken; -/* 262 */ As: AsToken : VerylToken; -/* 263 */ Assign: AssignToken : VerylToken; -/* 264 */ Bit: BitToken : VerylToken; -/* 265 */ Break: BreakToken : VerylToken; -/* 266 */ Case: CaseToken : VerylToken; -/* 267 */ Clock: ClockToken : VerylToken; -/* 268 */ ClockPosedge: ClockPosedgeToken : VerylToken; -/* 269 */ ClockNegedge: ClockNegedgeToken : VerylToken; -/* 270 */ Defaul: DefaultToken : VerylToken; -/* 271 */ Else: ElseToken : VerylToken; -/* 272 */ Embed: EmbedToken : VerylToken; -/* 273 */ Enum: EnumToken : VerylToken; -/* 274 */ Export: ExportToken : VerylToken; -/* 275 */ F32: F32Token : VerylToken; -/* 276 */ F64: F64Token : VerylToken; -/* 277 */ Final: FinalToken : VerylToken; -/* 278 */ For: ForToken : VerylToken; -/* 279 */ Function: FunctionToken : VerylToken; -/* 280 */ I32: I32Token : VerylToken; -/* 281 */ I64: I64Token : VerylToken; -/* 282 */ If: IfToken : VerylToken; -/* 283 */ IfReset: IfResetToken : VerylToken; -/* 284 */ Import: ImportToken : VerylToken; -/* 285 */ In: InToken : VerylToken; -/* 286 */ Include: IncludeToken : VerylToken; -/* 287 */ Initial: InitialToken : VerylToken; -/* 288 */ Inout: InoutToken : VerylToken; -/* 289 */ Input: InputToken : VerylToken; -/* 290 */ Inside: InsideToken : VerylToken; -/* 291 */ Inst: InstToken : VerylToken; -/* 292 */ Interface: InterfaceToken : VerylToken; -/* 293 */ Let: LetToken : VerylToken; -/* 294 */ Local: LocalToken : VerylToken; -/* 295 */ Logic: LogicToken : VerylToken; -/* 296 */ Lsb: LsbToken : VerylToken; -/* 297 */ Modport: ModportToken : VerylToken; -/* 298 */ Module: ModuleToken : VerylToken; -/* 299 */ Msb: MsbToken : VerylToken; -/* 300 */ Output: OutputToken : VerylToken; -/* 301 */ Outside: OutsideToken : VerylToken; -/* 302 */ Package: PackageToken : VerylToken; -/* 303 */ Param: ParamToken : VerylToken; -/* 304 */ Pub: PubToken : VerylToken; -/* 305 */ Ref: RefToken : VerylToken; -/* 306 */ Repeat: RepeatToken : VerylToken; -/* 307 */ Reset: ResetToken : VerylToken; -/* 308 */ ResetAsyncHigh: ResetAsyncHighToken : VerylToken; -/* 309 */ ResetAsyncLow: ResetAsyncLowToken : VerylToken; -/* 310 */ ResetSyncHigh: ResetSyncHighToken : VerylToken; -/* 311 */ ResetSyncLow: ResetSyncLowToken : VerylToken; -/* 312 */ Return: ReturnToken : VerylToken; -/* 313 */ Signed: SignedToken : VerylToken; -/* 314 */ Step: StepToken : VerylToken; -/* 315 */ Strin: StringToken : VerylToken; -/* 316 */ Struct: StructToken : VerylToken; -/* 317 */ Tri: TriToken : VerylToken; -/* 318 */ Type: TypeToken : VerylToken; -/* 319 */ U32: U32Token : VerylToken; -/* 320 */ U64: U64Token : VerylToken; -/* 321 */ Union: UnionToken : VerylToken; -/* 322 */ Var: VarToken : VerylToken; -/* 323 */ DollarIdentifier: DollarIdentifierToken : VerylToken; -/* 324 */ Identifier: IdentifierToken : VerylToken; -/* 325 */ Number: IntegralNumber; -/* 326 */ Number: RealNumber; -/* 327 */ IntegralNumber: Based; -/* 328 */ IntegralNumber: BaseLess; -/* 329 */ IntegralNumber: AllBit; -/* 330 */ RealNumber: FixedPoint; -/* 331 */ RealNumber: Exponent; -/* 332 */ HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */; -/* 333 */ HierarchicalIdentifierList0 /* Vec::Push */: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0; -/* 334 */ HierarchicalIdentifierList0List /* Vec::Push */: Select HierarchicalIdentifierList0List; -/* 335 */ HierarchicalIdentifierList0List /* Vec::New */: ; -/* 336 */ HierarchicalIdentifierList0 /* Vec::New */: ; -/* 337 */ HierarchicalIdentifierList /* Vec::Push */: Select HierarchicalIdentifierList; -/* 338 */ HierarchicalIdentifierList /* Vec::New */: ; -/* 339 */ ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */; -/* 340 */ ScopedIdentifierGroup: DollarIdentifier; -/* 341 */ ScopedIdentifierGroup: Identifier; -/* 342 */ ScopedIdentifierList /* Vec::Push */: ColonColon Identifier ScopedIdentifierList; -/* 343 */ ScopedIdentifierList /* Vec::New */: ; -/* 344 */ ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */; -/* 345 */ ExpressionIdentifierList0 /* Vec::Push */: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0; -/* 346 */ ExpressionIdentifierList0List /* Vec::Push */: Select ExpressionIdentifierList0List; -/* 347 */ ExpressionIdentifierList0List /* Vec::New */: ; -/* 348 */ ExpressionIdentifierList0 /* Vec::New */: ; -/* 349 */ ExpressionIdentifierList /* Vec::Push */: Select ExpressionIdentifierList; -/* 350 */ ExpressionIdentifierList /* Vec::New */: ; -/* 351 */ Expression: Expression01 ExpressionList /* Vec */; -/* 352 */ ExpressionList /* Vec::Push */: Operator01 Expression01 ExpressionList; -/* 353 */ ExpressionList /* Vec::New */: ; -/* 354 */ Expression01: Expression02 Expression01List /* Vec */; -/* 355 */ Expression01List /* Vec::Push */: Operator02 Expression02 Expression01List; -/* 356 */ Expression01List /* Vec::New */: ; -/* 357 */ Expression02: Expression03 Expression02List /* Vec */; -/* 358 */ Expression02List /* Vec::Push */: Operator03 Expression03 Expression02List; -/* 359 */ Expression02List /* Vec::New */: ; -/* 360 */ Expression03: Expression04 Expression03List /* Vec */; -/* 361 */ Expression03List /* Vec::Push */: Operator04 Expression04 Expression03List; -/* 362 */ Expression03List /* Vec::New */: ; -/* 363 */ Expression04: Expression05 Expression04List /* Vec */; -/* 364 */ Expression04List /* Vec::Push */: Operator05 Expression05 Expression04List; -/* 365 */ Expression04List /* Vec::New */: ; -/* 366 */ Expression05: Expression06 Expression05List /* Vec */; -/* 367 */ Expression05List /* Vec::Push */: Operator06 Expression06 Expression05List; -/* 368 */ Expression05List /* Vec::New */: ; -/* 369 */ Expression06: Expression07 Expression06List /* Vec */; -/* 370 */ Expression06List /* Vec::Push */: Operator07 Expression07 Expression06List; -/* 371 */ Expression06List /* Vec::New */: ; -/* 372 */ Expression07: Expression08 Expression07List /* Vec */; -/* 373 */ Expression07List /* Vec::Push */: Operator08 Expression08 Expression07List; -/* 374 */ Expression07List /* Vec::New */: ; -/* 375 */ Expression08: Expression09 Expression08List /* Vec */; -/* 376 */ Expression08List /* Vec::Push */: Operator09 Expression09 Expression08List; -/* 377 */ Expression08List /* Vec::New */: ; -/* 378 */ Expression09: Expression10 Expression09List /* Vec */; -/* 379 */ Expression09List /* Vec::Push */: Expression09ListGroup Expression10 Expression09List; -/* 380 */ Expression09ListGroup: Operator10; -/* 381 */ Expression09ListGroup: Star; -/* 382 */ Expression09List /* Vec::New */: ; -/* 383 */ Expression10: Expression11 Expression10List /* Vec */; -/* 384 */ Expression10List /* Vec::Push */: Operator11 Expression11 Expression10List; -/* 385 */ Expression10List /* Vec::New */: ; -/* 386 */ Expression11: Expression12 Expression11List /* Vec */; -/* 387 */ Expression11List /* Vec::Push */: As ScopedIdentifier Expression11List; -/* 388 */ Expression11List /* Vec::New */: ; -/* 389 */ Expression12: Expression12List /* Vec */ Factor; -/* 390 */ Expression12List /* Vec::Push */: Expression12ListGroup Expression12List; -/* 391 */ Expression12ListGroup: UnaryOperator; -/* 392 */ Expression12ListGroup: Operator09; -/* 393 */ Expression12ListGroup: Operator05; -/* 394 */ Expression12ListGroup: Operator03; -/* 395 */ Expression12ListGroup: Operator04; -/* 396 */ Expression12List /* Vec::New */: ; -/* 397 */ Factor: Number; -/* 398 */ Factor: ExpressionIdentifier FactorOpt /* Option */; -/* 399 */ Factor: LParen Expression RParen; -/* 400 */ Factor: LBrace ConcatenationList RBrace; -/* 401 */ Factor: QuoteLBrace ArrayLiteralList RBrace; -/* 402 */ Factor: IfExpression; -/* 403 */ Factor: CaseExpression; -/* 404 */ Factor: StringLiteral; -/* 405 */ Factor: FactorGroup; -/* 406 */ FactorGroup: Msb; -/* 407 */ FactorGroup: Lsb; -/* 408 */ Factor: InsideExpression; -/* 409 */ Factor: OutsideExpression; -/* 410 */ FactorOpt /* Option::Some */: FunctionCall; -/* 411 */ FactorOpt /* Option::None */: ; -/* 412 */ FunctionCall: LParen FunctionCallOpt /* Option */ RParen; -/* 413 */ FunctionCallOpt /* Option::Some */: ArgumentList; -/* 414 */ FunctionCallOpt /* Option::None */: ; -/* 415 */ ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */; -/* 416 */ ArgumentListList /* Vec::Push */: Comma ArgumentItem ArgumentListList; -/* 417 */ ArgumentListList /* Vec::New */: ; -/* 418 */ ArgumentListOpt /* Option::Some */: Comma; -/* 419 */ ArgumentListOpt /* Option::None */: ; -/* 420 */ ArgumentItem: Expression; -/* 421 */ ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */; -/* 422 */ ConcatenationListList /* Vec::Push */: Comma ConcatenationItem ConcatenationListList; -/* 423 */ ConcatenationListList /* Vec::New */: ; -/* 424 */ ConcatenationListOpt /* Option::Some */: Comma; -/* 425 */ ConcatenationListOpt /* Option::None */: ; -/* 426 */ ConcatenationItem: Expression ConcatenationItemOpt /* Option */; -/* 427 */ ConcatenationItemOpt /* Option::Some */: Repeat Expression; -/* 428 */ ConcatenationItemOpt /* Option::None */: ; -/* 429 */ ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */; -/* 430 */ ArrayLiteralListList /* Vec::Push */: Comma ArrayLiteralItem ArrayLiteralListList; -/* 431 */ ArrayLiteralListList /* Vec::New */: ; -/* 432 */ ArrayLiteralListOpt /* Option::Some */: Comma; -/* 433 */ ArrayLiteralListOpt /* Option::None */: ; -/* 434 */ ArrayLiteralItem: ArrayLiteralItemGroup; -/* 435 */ ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */; -/* 436 */ ArrayLiteralItemGroup: Defaul Colon Expression; -/* 437 */ ArrayLiteralItemOpt /* Option::Some */: Repeat Expression; -/* 438 */ ArrayLiteralItemOpt /* Option::None */: ; -/* 439 */ IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace; -/* 440 */ IfExpressionList /* Vec::Push */: Else If Expression LBrace Expression RBrace IfExpressionList; -/* 441 */ IfExpressionList /* Vec::New */: ; -/* 442 */ CaseExpression: Case Expression LBrace Expression CaseExpressionList /* Vec */ Colon Expression Comma CaseExpressionList0 /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace; -/* 443 */ CaseExpressionList0 /* Vec::Push */: Expression CaseExpressionList0List /* Vec */ Colon Expression Comma CaseExpressionList0; -/* 444 */ CaseExpressionList0List /* Vec::Push */: Comma Expression CaseExpressionList0List; -/* 445 */ CaseExpressionList0List /* Vec::New */: ; -/* 446 */ CaseExpressionList0 /* Vec::New */: ; -/* 447 */ CaseExpressionList /* Vec::Push */: Comma Expression CaseExpressionList; -/* 448 */ CaseExpressionList /* Vec::New */: ; -/* 449 */ CaseExpressionOpt /* Option::Some */: Comma; -/* 450 */ CaseExpressionOpt /* Option::None */: ; -/* 451 */ TypeExpression: ScalarType; -/* 452 */ TypeExpression: Type LParen Expression RParen; -/* 453 */ InsideExpression: Inside Expression LBrace RangeList RBrace; -/* 454 */ OutsideExpression: Outside Expression LBrace RangeList RBrace; -/* 455 */ RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */; -/* 456 */ RangeListList /* Vec::Push */: Comma RangeItem RangeListList; -/* 457 */ RangeListList /* Vec::New */: ; -/* 458 */ RangeListOpt /* Option::Some */: Comma; -/* 459 */ RangeListOpt /* Option::None */: ; -/* 460 */ RangeItem: Range; -/* 461 */ Select: LBracket Expression SelectOpt /* Option */ RBracket; -/* 462 */ SelectOpt /* Option::Some */: SelectOperator Expression; -/* 463 */ SelectOpt /* Option::None */: ; -/* 464 */ SelectOperator: Colon; -/* 465 */ SelectOperator: PlusColon; -/* 466 */ SelectOperator: MinusColon; -/* 467 */ SelectOperator: Step; -/* 468 */ Width: LAngle Expression WidthList /* Vec */ RAngle; -/* 469 */ WidthList /* Vec::Push */: Comma Expression WidthList; -/* 470 */ WidthList /* Vec::New */: ; -/* 471 */ Array: LBracket Expression ArrayList /* Vec */ RBracket; -/* 472 */ ArrayList /* Vec::Push */: Comma Expression ArrayList; -/* 473 */ ArrayList /* Vec::New */: ; -/* 474 */ Range: Expression RangeOpt /* Option */; -/* 475 */ RangeOpt /* Option::Some */: RangeOperator Expression; -/* 476 */ RangeOpt /* Option::None */: ; -/* 477 */ RangeOperator: DotDot; -/* 478 */ RangeOperator: DotDotEqu; -/* 479 */ FixedType: U32; -/* 480 */ FixedType: U64; -/* 481 */ FixedType: I32; -/* 482 */ FixedType: I64; -/* 483 */ FixedType: F32; -/* 484 */ FixedType: F64; -/* 485 */ FixedType: Strin; -/* 486 */ VariableType: VariableTypeGroup VariableTypeOpt /* Option */; -/* 487 */ VariableTypeGroup: Clock; -/* 488 */ VariableTypeGroup: ClockPosedge; -/* 489 */ VariableTypeGroup: ClockNegedge; -/* 490 */ VariableTypeGroup: Reset; -/* 491 */ VariableTypeGroup: ResetAsyncHigh; -/* 492 */ VariableTypeGroup: ResetAsyncLow; -/* 493 */ VariableTypeGroup: ResetSyncHigh; -/* 494 */ VariableTypeGroup: ResetSyncLow; -/* 495 */ VariableTypeGroup: Logic; -/* 496 */ VariableTypeGroup: Bit; -/* 497 */ VariableTypeGroup: ScopedIdentifier; -/* 498 */ VariableTypeOpt /* Option::Some */: Width; -/* 499 */ VariableTypeOpt /* Option::None */: ; -/* 500 */ TypeModifier: Tri; -/* 501 */ TypeModifier: Signed; -/* 502 */ ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup; -/* 503 */ ScalarTypeGroup: VariableType; -/* 504 */ ScalarTypeGroup: FixedType; -/* 505 */ ScalarTypeList /* Vec::Push */: TypeModifier ScalarTypeList; -/* 506 */ ScalarTypeList /* Vec::New */: ; -/* 507 */ ArrayType: ScalarType ArrayTypeOpt /* Option */; -/* 508 */ ArrayTypeOpt /* Option::Some */: Array; -/* 509 */ ArrayTypeOpt /* Option::None */: ; -/* 510 */ Statement: LetStatement; -/* 511 */ Statement: IdentifierStatement; -/* 512 */ Statement: IfStatement; -/* 513 */ Statement: IfResetStatement; -/* 514 */ Statement: ReturnStatement; -/* 515 */ Statement: BreakStatement; -/* 516 */ Statement: ForStatement; -/* 517 */ Statement: CaseStatement; -/* 518 */ LetStatement: Let Identifier Colon ArrayType Equ Expression Semicolon; -/* 519 */ IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon; -/* 520 */ IdentifierStatementGroup: FunctionCall; -/* 521 */ IdentifierStatementGroup: Assignment; -/* 522 */ Assignment: AssignmentGroup Expression; -/* 523 */ AssignmentGroup: Equ; -/* 524 */ AssignmentGroup: AssignmentOperator; -/* 525 */ IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */; -/* 526 */ IfStatementList0 /* Vec::Push */: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0; -/* 527 */ IfStatementList0List /* Vec::Push */: Statement IfStatementList0List; -/* 528 */ IfStatementList0List /* Vec::New */: ; -/* 529 */ IfStatementList0 /* Vec::New */: ; -/* 530 */ IfStatementList /* Vec::Push */: Statement IfStatementList; -/* 531 */ IfStatementList /* Vec::New */: ; -/* 532 */ IfStatementOpt /* Option::Some */: Else LBrace IfStatementOptList /* Vec */ RBrace; -/* 533 */ IfStatementOptList /* Vec::Push */: Statement IfStatementOptList; -/* 534 */ IfStatementOptList /* Vec::New */: ; -/* 535 */ IfStatementOpt /* Option::None */: ; -/* 536 */ IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */; -/* 537 */ IfResetStatementList0 /* Vec::Push */: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0; -/* 538 */ IfResetStatementList0List /* Vec::Push */: Statement IfResetStatementList0List; -/* 539 */ IfResetStatementList0List /* Vec::New */: ; -/* 540 */ IfResetStatementList0 /* Vec::New */: ; -/* 541 */ IfResetStatementList /* Vec::Push */: Statement IfResetStatementList; -/* 542 */ IfResetStatementList /* Vec::New */: ; -/* 543 */ IfResetStatementOpt /* Option::Some */: Else LBrace IfResetStatementOptList /* Vec */ RBrace; -/* 544 */ IfResetStatementOptList /* Vec::Push */: Statement IfResetStatementOptList; -/* 545 */ IfResetStatementOptList /* Vec::New */: ; -/* 546 */ IfResetStatementOpt /* Option::None */: ; -/* 547 */ ReturnStatement: Return Expression Semicolon; -/* 548 */ BreakStatement: Break Semicolon; -/* 549 */ ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace; -/* 550 */ ForStatementList /* Vec::Push */: Statement ForStatementList; -/* 551 */ ForStatementList /* Vec::New */: ; -/* 552 */ ForStatementOpt /* Option::Some */: Step AssignmentOperator Expression; -/* 553 */ ForStatementOpt /* Option::None */: ; -/* 554 */ CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace; -/* 555 */ CaseStatementList /* Vec::Push */: CaseItem CaseStatementList; -/* 556 */ CaseStatementList /* Vec::New */: ; -/* 557 */ CaseItem: CaseItemGroup Colon CaseItemGroup0; -/* 558 */ CaseItemGroup0: Statement; -/* 559 */ CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace; -/* 560 */ CaseItemGroup0List /* Vec::Push */: Statement CaseItemGroup0List; -/* 561 */ CaseItemGroup0List /* Vec::New */: ; -/* 562 */ CaseItemGroup: Expression CaseItemGroupList /* Vec */; -/* 563 */ CaseItemGroupList /* Vec::Push */: Comma Expression CaseItemGroupList; -/* 564 */ CaseItemGroupList /* Vec::New */: ; -/* 565 */ CaseItemGroup: Defaul; -/* 566 */ Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket; -/* 567 */ AttributeOpt /* Option::Some */: LParen AttributeList RParen; -/* 568 */ AttributeOpt /* Option::None */: ; -/* 569 */ AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */; -/* 570 */ AttributeListList /* Vec::Push */: Comma AttributeItem AttributeListList; -/* 571 */ AttributeListList /* Vec::New */: ; -/* 572 */ AttributeListOpt /* Option::Some */: Comma; -/* 573 */ AttributeListOpt /* Option::None */: ; -/* 574 */ AttributeItem: Identifier; -/* 575 */ AttributeItem: StringLiteral; -/* 576 */ LetDeclaration: Let Identifier Colon ArrayType Equ Expression Semicolon; -/* 577 */ VarDeclaration: Var Identifier Colon ArrayType Semicolon; -/* 578 */ LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon; -/* 579 */ LocalDeclarationGroup: ArrayType Equ Expression; -/* 580 */ LocalDeclarationGroup: Type Equ TypeExpression; -/* 581 */ TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon; -/* 582 */ AlwaysFfDeclaration: AlwaysFf LParen AlwaysFfClock AlwaysFfDeclarationOpt /* Option */ RParen LBrace AlwaysFfDeclarationList /* Vec */ RBrace; -/* 583 */ AlwaysFfDeclarationList /* Vec::Push */: Statement AlwaysFfDeclarationList; -/* 584 */ AlwaysFfDeclarationList /* Vec::New */: ; -/* 585 */ AlwaysFfDeclarationOpt /* Option::Some */: Comma AlwaysFfReset; -/* 586 */ AlwaysFfDeclarationOpt /* Option::None */: ; -/* 587 */ AlwaysFfClock: HierarchicalIdentifier; -/* 588 */ AlwaysFfReset: HierarchicalIdentifier; -/* 589 */ AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace; -/* 590 */ AlwaysCombDeclarationList /* Vec::Push */: Statement AlwaysCombDeclarationList; -/* 591 */ AlwaysCombDeclarationList /* Vec::New */: ; -/* 592 */ AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon; -/* 593 */ ModportDeclaration: Modport Identifier LBrace ModportList RBrace; -/* 594 */ ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */; -/* 595 */ ModportListList /* Vec::Push */: Comma ModportGroup ModportListList; -/* 596 */ ModportListList /* Vec::New */: ; -/* 597 */ ModportListOpt /* Option::Some */: Comma; -/* 598 */ ModportListOpt /* Option::None */: ; -/* 599 */ ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup; -/* 600 */ ModportGroupGroup: LBrace ModportList RBrace; -/* 601 */ ModportGroupGroup: ModportItem; -/* 602 */ ModportGroupList /* Vec::Push */: Attribute ModportGroupList; -/* 603 */ ModportGroupList /* Vec::New */: ; -/* 604 */ ModportItem: Identifier Colon Direction; -/* 605 */ EnumDeclaration: Enum Identifier Colon ScalarType LBrace EnumList RBrace; -/* 606 */ EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */; -/* 607 */ EnumListList /* Vec::Push */: Comma EnumGroup EnumListList; -/* 608 */ EnumListList /* Vec::New */: ; -/* 609 */ EnumListOpt /* Option::Some */: Comma; -/* 610 */ EnumListOpt /* Option::None */: ; -/* 611 */ EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup; -/* 612 */ EnumGroupGroup: LBrace EnumList RBrace; -/* 613 */ EnumGroupGroup: EnumItem; -/* 614 */ EnumGroupList /* Vec::Push */: Attribute EnumGroupList; -/* 615 */ EnumGroupList /* Vec::New */: ; -/* 616 */ EnumItem: Identifier EnumItemOpt /* Option */; -/* 617 */ EnumItemOpt /* Option::Some */: Equ Expression; -/* 618 */ EnumItemOpt /* Option::None */: ; -/* 619 */ StructUnion: Struct; -/* 620 */ StructUnion: Union; -/* 621 */ StructUnionDeclaration: StructUnion Identifier LBrace StructUnionList RBrace; -/* 622 */ StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */; -/* 623 */ StructUnionListList /* Vec::Push */: Comma StructUnionGroup StructUnionListList; -/* 624 */ StructUnionListList /* Vec::New */: ; -/* 625 */ StructUnionListOpt /* Option::Some */: Comma; -/* 626 */ StructUnionListOpt /* Option::None */: ; -/* 627 */ StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup; -/* 628 */ StructUnionGroupGroup: LBrace StructUnionList RBrace; -/* 629 */ StructUnionGroupGroup: StructUnionItem; -/* 630 */ StructUnionGroupList /* Vec::Push */: Attribute StructUnionGroupList; -/* 631 */ StructUnionGroupList /* Vec::New */: ; -/* 632 */ StructUnionItem: Identifier Colon ScalarType; -/* 633 */ InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace; -/* 634 */ InitialDeclarationList /* Vec::Push */: Statement InitialDeclarationList; -/* 635 */ InitialDeclarationList /* Vec::New */: ; -/* 636 */ FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace; -/* 637 */ FinalDeclarationList /* Vec::Push */: Statement FinalDeclarationList; -/* 638 */ FinalDeclarationList /* Vec::New */: ; -/* 639 */ InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon; -/* 640 */ InstDeclarationOpt1 /* Option::Some */: LParen InstDeclarationOpt2 /* Option */ RParen; -/* 641 */ InstDeclarationOpt2 /* Option::Some */: InstPortList; -/* 642 */ InstDeclarationOpt2 /* Option::None */: ; -/* 643 */ InstDeclarationOpt1 /* Option::None */: ; -/* 644 */ InstDeclarationOpt0 /* Option::Some */: InstParameter; -/* 645 */ InstDeclarationOpt0 /* Option::None */: ; -/* 646 */ InstDeclarationOpt /* Option::Some */: Array; -/* 647 */ InstDeclarationOpt /* Option::None */: ; -/* 648 */ InstParameter: Hash LParen InstParameterOpt /* Option */ RParen; -/* 649 */ InstParameterOpt /* Option::Some */: InstParameterList; -/* 650 */ InstParameterOpt /* Option::None */: ; -/* 651 */ InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */; -/* 652 */ InstParameterListList /* Vec::Push */: Comma InstParameterGroup InstParameterListList; -/* 653 */ InstParameterListList /* Vec::New */: ; -/* 654 */ InstParameterListOpt /* Option::Some */: Comma; -/* 655 */ InstParameterListOpt /* Option::None */: ; -/* 656 */ InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup; -/* 657 */ InstParameterGroupGroup: LBrace InstParameterList RBrace; -/* 658 */ InstParameterGroupGroup: InstParameterItem; -/* 659 */ InstParameterGroupList /* Vec::Push */: Attribute InstParameterGroupList; -/* 660 */ InstParameterGroupList /* Vec::New */: ; -/* 661 */ InstParameterItem: Identifier InstParameterItemOpt /* Option */; -/* 662 */ InstParameterItemOpt /* Option::Some */: Colon Expression; -/* 663 */ InstParameterItemOpt /* Option::None */: ; -/* 664 */ InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */; -/* 665 */ InstPortListList /* Vec::Push */: Comma InstPortGroup InstPortListList; -/* 666 */ InstPortListList /* Vec::New */: ; -/* 667 */ InstPortListOpt /* Option::Some */: Comma; -/* 668 */ InstPortListOpt /* Option::None */: ; -/* 669 */ InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup; -/* 670 */ InstPortGroupGroup: LBrace InstPortList RBrace; -/* 671 */ InstPortGroupGroup: InstPortItem; -/* 672 */ InstPortGroupList /* Vec::Push */: Attribute InstPortGroupList; -/* 673 */ InstPortGroupList /* Vec::New */: ; -/* 674 */ InstPortItem: Identifier InstPortItemOpt /* Option */; -/* 675 */ InstPortItemOpt /* Option::Some */: Colon Expression; -/* 676 */ InstPortItemOpt /* Option::None */: ; -/* 677 */ WithParameter: Hash LParen WithParameterOpt /* Option */ RParen; -/* 678 */ WithParameterOpt /* Option::Some */: WithParameterList; -/* 679 */ WithParameterOpt /* Option::None */: ; -/* 680 */ WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */; -/* 681 */ WithParameterListList /* Vec::Push */: Comma WithParameterGroup WithParameterListList; -/* 682 */ WithParameterListList /* Vec::New */: ; -/* 683 */ WithParameterListOpt /* Option::Some */: Comma; -/* 684 */ WithParameterListOpt /* Option::None */: ; -/* 685 */ WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup; -/* 686 */ WithParameterGroupGroup: LBrace WithParameterList RBrace; -/* 687 */ WithParameterGroupGroup: WithParameterItem; -/* 688 */ WithParameterGroupList /* Vec::Push */: Attribute WithParameterGroupList; -/* 689 */ WithParameterGroupList /* Vec::New */: ; -/* 690 */ WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0; -/* 691 */ WithParameterItemGroup0: ArrayType Equ Expression; -/* 692 */ WithParameterItemGroup0: Type Equ TypeExpression; -/* 693 */ WithParameterItemGroup: Param; -/* 694 */ WithParameterItemGroup: Local; -/* 695 */ PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen; -/* 696 */ PortDeclarationOpt /* Option::Some */: PortDeclarationList; -/* 697 */ PortDeclarationOpt /* Option::None */: ; -/* 698 */ PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */; -/* 699 */ PortDeclarationListList /* Vec::Push */: Comma PortDeclarationGroup PortDeclarationListList; -/* 700 */ PortDeclarationListList /* Vec::New */: ; -/* 701 */ PortDeclarationListOpt /* Option::Some */: Comma; -/* 702 */ PortDeclarationListOpt /* Option::None */: ; -/* 703 */ PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup; -/* 704 */ PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace; -/* 705 */ PortDeclarationGroupGroup: PortDeclarationItem; -/* 706 */ PortDeclarationGroupList /* Vec::Push */: Attribute PortDeclarationGroupList; -/* 707 */ PortDeclarationGroupList /* Vec::New */: ; -/* 708 */ PortDeclarationItem: Identifier Colon PortDeclarationItemGroup; -/* 709 */ PortDeclarationItemGroup: Direction ArrayType; -/* 710 */ PortDeclarationItemGroup: Interface PortDeclarationItemOpt /* Option */; -/* 711 */ PortDeclarationItemOpt /* Option::Some */: Array; -/* 712 */ PortDeclarationItemOpt /* Option::None */: ; -/* 713 */ Direction: Input; -/* 714 */ Direction: Output; -/* 715 */ Direction: Inout; -/* 716 */ Direction: Ref; -/* 717 */ Direction: Modport; -/* 718 */ FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace; -/* 719 */ FunctionDeclarationList /* Vec::Push */: FunctionItem FunctionDeclarationList; -/* 720 */ FunctionDeclarationList /* Vec::New */: ; -/* 721 */ FunctionDeclarationOpt0 /* Option::Some */: MinusGT ScalarType; -/* 722 */ FunctionDeclarationOpt0 /* Option::None */: ; -/* 723 */ FunctionDeclarationOpt /* Option::Some */: PortDeclaration; -/* 724 */ FunctionDeclarationOpt /* Option::None */: ; -/* 725 */ FunctionItem: VarDeclaration; -/* 726 */ FunctionItem: Statement; -/* 727 */ ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon; -/* 728 */ ImportDeclarationOpt /* Option::Some */: ColonColon Star; -/* 729 */ ImportDeclarationOpt /* Option::None */: ; -/* 730 */ ExportDeclaration: Export ExportDeclarationGroup Semicolon; -/* 731 */ ExportDeclarationGroup: Star; -/* 732 */ ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */; -/* 733 */ ExportDeclarationOpt /* Option::Some */: ColonColon Star; -/* 734 */ ExportDeclarationOpt /* Option::None */: ; -/* 735 */ ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace; -/* 736 */ ModuleDeclarationList /* Vec::Push */: ModuleGroup ModuleDeclarationList; -/* 737 */ ModuleDeclarationList /* Vec::New */: ; -/* 738 */ ModuleDeclarationOpt1 /* Option::Some */: PortDeclaration; -/* 739 */ ModuleDeclarationOpt1 /* Option::None */: ; -/* 740 */ ModuleDeclarationOpt0 /* Option::Some */: WithParameter; -/* 741 */ ModuleDeclarationOpt0 /* Option::None */: ; -/* 742 */ ModuleDeclarationOpt /* Option::Some */: Pub; -/* 743 */ ModuleDeclarationOpt /* Option::None */: ; -/* 744 */ ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */; -/* 745 */ ModuleIfDeclarationList /* Vec::Push */: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList; -/* 746 */ ModuleIfDeclarationList /* Vec::New */: ; -/* 747 */ ModuleIfDeclarationOpt /* Option::Some */: Else ModuleOptionalNamedBlock; -/* 748 */ ModuleIfDeclarationOpt /* Option::None */: ; -/* 749 */ ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock; -/* 750 */ ModuleForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression; -/* 751 */ ModuleForDeclarationOpt /* Option::None */: ; -/* 752 */ ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace; -/* 753 */ ModuleNamedBlockList /* Vec::Push */: ModuleGroup ModuleNamedBlockList; -/* 754 */ ModuleNamedBlockList /* Vec::New */: ; -/* 755 */ ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace; -/* 756 */ ModuleOptionalNamedBlockList /* Vec::Push */: ModuleGroup ModuleOptionalNamedBlockList; -/* 757 */ ModuleOptionalNamedBlockList /* Vec::New */: ; -/* 758 */ ModuleOptionalNamedBlockOpt /* Option::Some */: Colon Identifier; -/* 759 */ ModuleOptionalNamedBlockOpt /* Option::None */: ; -/* 760 */ ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup; -/* 761 */ ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace; -/* 762 */ ModuleGroupGroupList /* Vec::Push */: ModuleGroup ModuleGroupGroupList; -/* 763 */ ModuleGroupGroupList /* Vec::New */: ; -/* 764 */ ModuleGroupGroup: ModuleItem; -/* 765 */ ModuleGroupList /* Vec::Push */: Attribute ModuleGroupList; -/* 766 */ ModuleGroupList /* Vec::New */: ; -/* 767 */ ModuleItem: LetDeclaration; -/* 768 */ ModuleItem: VarDeclaration; -/* 769 */ ModuleItem: InstDeclaration; -/* 770 */ ModuleItem: TypeDefDeclaration; -/* 771 */ ModuleItem: LocalDeclaration; -/* 772 */ ModuleItem: AlwaysFfDeclaration; -/* 773 */ ModuleItem: AlwaysCombDeclaration; -/* 774 */ ModuleItem: AssignDeclaration; -/* 775 */ ModuleItem: FunctionDeclaration; -/* 776 */ ModuleItem: ModuleIfDeclaration; -/* 777 */ ModuleItem: ModuleForDeclaration; -/* 778 */ ModuleItem: EnumDeclaration; -/* 779 */ ModuleItem: StructUnionDeclaration; -/* 780 */ ModuleItem: ModuleNamedBlock; -/* 781 */ ModuleItem: ImportDeclaration; -/* 782 */ ModuleItem: InitialDeclaration; -/* 783 */ ModuleItem: FinalDeclaration; -/* 784 */ InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace; -/* 785 */ InterfaceDeclarationList /* Vec::Push */: InterfaceGroup InterfaceDeclarationList; -/* 786 */ InterfaceDeclarationList /* Vec::New */: ; -/* 787 */ InterfaceDeclarationOpt0 /* Option::Some */: WithParameter; -/* 788 */ InterfaceDeclarationOpt0 /* Option::None */: ; -/* 789 */ InterfaceDeclarationOpt /* Option::Some */: Pub; -/* 790 */ InterfaceDeclarationOpt /* Option::None */: ; -/* 791 */ InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */; -/* 792 */ InterfaceIfDeclarationList /* Vec::Push */: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList; -/* 793 */ InterfaceIfDeclarationList /* Vec::New */: ; -/* 794 */ InterfaceIfDeclarationOpt /* Option::Some */: Else InterfaceOptionalNamedBlock; -/* 795 */ InterfaceIfDeclarationOpt /* Option::None */: ; -/* 796 */ InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock; -/* 797 */ InterfaceForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression; -/* 798 */ InterfaceForDeclarationOpt /* Option::None */: ; -/* 799 */ InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace; -/* 800 */ InterfaceNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceNamedBlockList; -/* 801 */ InterfaceNamedBlockList /* Vec::New */: ; -/* 802 */ InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace; -/* 803 */ InterfaceOptionalNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceOptionalNamedBlockList; -/* 804 */ InterfaceOptionalNamedBlockList /* Vec::New */: ; -/* 805 */ InterfaceOptionalNamedBlockOpt /* Option::Some */: Colon Identifier; -/* 806 */ InterfaceOptionalNamedBlockOpt /* Option::None */: ; -/* 807 */ InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup; -/* 808 */ InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace; -/* 809 */ InterfaceGroupGroupList /* Vec::Push */: InterfaceGroup InterfaceGroupGroupList; -/* 810 */ InterfaceGroupGroupList /* Vec::New */: ; -/* 811 */ InterfaceGroupGroup: InterfaceItem; -/* 812 */ InterfaceGroupList /* Vec::Push */: Attribute InterfaceGroupList; -/* 813 */ InterfaceGroupList /* Vec::New */: ; -/* 814 */ InterfaceItem: LetDeclaration; -/* 815 */ InterfaceItem: VarDeclaration; -/* 816 */ InterfaceItem: LocalDeclaration; -/* 817 */ InterfaceItem: ModportDeclaration; -/* 818 */ InterfaceItem: InterfaceIfDeclaration; -/* 819 */ InterfaceItem: InterfaceForDeclaration; -/* 820 */ InterfaceItem: TypeDefDeclaration; -/* 821 */ InterfaceItem: EnumDeclaration; -/* 822 */ InterfaceItem: StructUnionDeclaration; -/* 823 */ InterfaceItem: InterfaceNamedBlock; -/* 824 */ InterfaceItem: FunctionDeclaration; -/* 825 */ InterfaceItem: ImportDeclaration; -/* 826 */ InterfaceItem: InitialDeclaration; -/* 827 */ InterfaceItem: FinalDeclaration; -/* 828 */ PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier LBrace PackageDeclarationList /* Vec */ RBrace; -/* 829 */ PackageDeclarationList /* Vec::Push */: PackageGroup PackageDeclarationList; -/* 830 */ PackageDeclarationList /* Vec::New */: ; -/* 831 */ PackageDeclarationOpt /* Option::Some */: Pub; -/* 832 */ PackageDeclarationOpt /* Option::None */: ; -/* 833 */ PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup; -/* 834 */ PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace; -/* 835 */ PackageGroupGroupList /* Vec::Push */: PackageGroup PackageGroupGroupList; -/* 836 */ PackageGroupGroupList /* Vec::New */: ; -/* 837 */ PackageGroupGroup: PackageItem; -/* 838 */ PackageGroupList /* Vec::Push */: Attribute PackageGroupList; -/* 839 */ PackageGroupList /* Vec::New */: ; -/* 840 */ PackageItem: VarDeclaration; -/* 841 */ PackageItem: LocalDeclaration; -/* 842 */ PackageItem: TypeDefDeclaration; -/* 843 */ PackageItem: EnumDeclaration; -/* 844 */ PackageItem: StructUnionDeclaration; -/* 845 */ PackageItem: FunctionDeclaration; -/* 846 */ PackageItem: ImportDeclaration; -/* 847 */ PackageItem: ExportDeclaration; -/* 848 */ PackageItem: InitialDeclaration; -/* 849 */ PackageItem: FinalDeclaration; -/* 850 */ EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent; -/* 851 */ EmbedContent: EmbedContentToken : VerylToken; -/* 852 */ EmbedContentToken: LBraceTerm %push(Embed) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm %pop(); -/* 853 */ EmbedContentTokenList /* Vec::Push */: EmbedItem EmbedContentTokenList; -/* 854 */ EmbedContentTokenList /* Vec::New */: ; -/* 855 */ EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm; -/* 856 */ EmbedItemList /* Vec::Push */: EmbedItem EmbedItemList; -/* 857 */ EmbedItemList /* Vec::New */: ; -/* 858 */ EmbedItem: AnyTerm; -/* 859 */ IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon; -/* 860 */ DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup; -/* 861 */ DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace; -/* 862 */ DescriptionGroupGroupList /* Vec::Push */: DescriptionGroup DescriptionGroupGroupList; -/* 863 */ DescriptionGroupGroupList /* Vec::New */: ; -/* 864 */ DescriptionGroupGroup: DescriptionItem; -/* 865 */ DescriptionGroupList /* Vec::Push */: Attribute DescriptionGroupList; -/* 866 */ DescriptionGroupList /* Vec::New */: ; -/* 867 */ DescriptionItem: ModuleDeclaration; -/* 868 */ DescriptionItem: InterfaceDeclaration; -/* 869 */ DescriptionItem: PackageDeclaration; -/* 870 */ DescriptionItem: ImportDeclaration; -/* 871 */ DescriptionItem: EmbedDeclaration; -/* 872 */ DescriptionItem: IncludeDeclaration; -/* 873 */ Veryl: Start VerylList /* Vec */; -/* 874 */ VerylList /* Vec::Push */: DescriptionGroup VerylList; -/* 875 */ VerylList /* Vec::New */: ; +/* 23 */ ColonColonLAngleTerm: '::<' : Token; +/* 24 */ ColonColonTerm: '::' : Token; +/* 25 */ ColonTerm: ':' : Token; +/* 26 */ CommaTerm: ',' : Token; +/* 27 */ DotDotEquTerm: '..=' : Token; +/* 28 */ DotDotTerm: '..' : Token; +/* 29 */ DotTerm: '.' : Token; +/* 30 */ EquTerm: '=' : Token; +/* 31 */ HashTerm: '#' : Token; +/* 32 */ LAngleTerm: '<' : Token; +/* 33 */ QuoteLBraceTerm: "'\{" : Token; +/* 34 */ LBraceTerm: '{' : Token; +/* 35 */ LBracketTerm: '[' : Token; +/* 36 */ LParenTerm: '(' : Token; +/* 37 */ RAngleTerm: '>' : Token; +/* 38 */ RBraceTerm: '}' : Token; +/* 39 */ RBracketTerm: ']' : Token; +/* 40 */ RParenTerm: ')' : Token; +/* 41 */ SemicolonTerm: ';' : Token; +/* 42 */ StarTerm: '*' : Token; +/* 43 */ AlwaysCombTerm: /(?-u:\b)always_comb(?-u:\b)/ : Token; +/* 44 */ AlwaysFfTerm: /(?-u:\b)always_ff(?-u:\b)/ : Token; +/* 45 */ AssignTerm: /(?-u:\b)assign(?-u:\b)/ : Token; +/* 46 */ AsTerm: /(?-u:\b)as(?-u:\b)/ : Token; +/* 47 */ BitTerm: /(?-u:\b)bit(?-u:\b)/ : Token; +/* 48 */ CaseTerm: /(?-u:\b)case(?-u:\b)/ : Token; +/* 49 */ ClockTerm: /(?-u:\b)clock(?-u:\b)/ : Token; +/* 50 */ ClockPosedgeTerm: /(?-u:\b)clock_posedge(?-u:\b)/ : Token; +/* 51 */ ClockNegedgeTerm: /(?-u:\b)clock_negedge(?-u:\b)/ : Token; +/* 52 */ DefaultTerm: /(?-u:\b)default(?-u:\b)/ : Token; +/* 53 */ ElseTerm: /(?-u:\b)else(?-u:\b)/ : Token; +/* 54 */ EmbedTerm: /(?-u:\b)embed(?-u:\b)/ : Token; +/* 55 */ EnumTerm: /(?-u:\b)enum(?-u:\b)/ : Token; +/* 56 */ ExportTerm: /(?-u:\b)export(?-u:\b)/ : Token; +/* 57 */ F32Term: /(?-u:\b)f32(?-u:\b)/ : Token; +/* 58 */ F64Term: /(?-u:\b)f64(?-u:\b)/ : Token; +/* 59 */ FinalTerm: /(?-u:\b)final(?-u:\b)/ : Token; +/* 60 */ ForTerm: /(?-u:\b)for(?-u:\b)/ : Token; +/* 61 */ FunctionTerm: /(?-u:\b)function(?-u:\b)/ : Token; +/* 62 */ I32Term: /(?-u:\b)i32(?-u:\b)/ : Token; +/* 63 */ I64Term: /(?-u:\b)i64(?-u:\b)/ : Token; +/* 64 */ IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/ : Token; +/* 65 */ IfTerm: /(?-u:\b)if(?-u:\b)/ : Token; +/* 66 */ ImportTerm: /(?-u:\b)import(?-u:\b)/ : Token; +/* 67 */ IncludeTerm: /(?-u:\b)include(?-u:\b)/ : Token; +/* 68 */ InitialTerm: /(?-u:\b)initial(?-u:\b)/ : Token; +/* 69 */ InoutTerm: /(?-u:\b)inout(?-u:\b)/ : Token; +/* 70 */ InputTerm: /(?-u:\b)input(?-u:\b)/ : Token; +/* 71 */ InsideTerm: /(?-u:\b)inside(?-u:\b)/ : Token; +/* 72 */ InstTerm: /(?-u:\b)inst(?-u:\b)/ : Token; +/* 73 */ InterfaceTerm: /(?-u:\b)interface(?-u:\b)/ : Token; +/* 74 */ InTerm: /(?-u:\b)in(?-u:\b)/ : Token; +/* 75 */ LetTerm: /(?-u:\b)let(?-u:\b)/ : Token; +/* 76 */ LocalTerm: /(?-u:\b)local(?-u:\b)/ : Token; +/* 77 */ LogicTerm: /(?-u:\b)logic(?-u:\b)/ : Token; +/* 78 */ LsbTerm: /(?-u:\b)lsb(?-u:\b)/ : Token; +/* 79 */ ModportTerm: /(?-u:\b)modport(?-u:\b)/ : Token; +/* 80 */ ModuleTerm: /(?-u:\b)module(?-u:\b)/ : Token; +/* 81 */ MsbTerm: /(?-u:\b)msb(?-u:\b)/ : Token; +/* 82 */ OutputTerm: /(?-u:\b)output(?-u:\b)/ : Token; +/* 83 */ OutsideTerm: /(?-u:\b)outside(?-u:\b)/ : Token; +/* 84 */ PackageTerm: /(?-u:\b)package(?-u:\b)/ : Token; +/* 85 */ ParamTerm: /(?-u:\b)param(?-u:\b)/ : Token; +/* 86 */ PubTerm: /(?-u:\b)pub(?-u:\b)/ : Token; +/* 87 */ RefTerm: /(?-u:\b)ref(?-u:\b)/ : Token; +/* 88 */ RepeatTerm: /(?-u:\b)repeat(?-u:\b)/ : Token; +/* 89 */ ResetTerm: /(?-u:\b)reset(?-u:\b)/ : Token; +/* 90 */ ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/ : Token; +/* 91 */ ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/ : Token; +/* 92 */ ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/ : Token; +/* 93 */ ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/ : Token; +/* 94 */ ReturnTerm: /(?-u:\b)return(?-u:\b)/ : Token; +/* 95 */ BreakTerm: /(?-u:\b)break(?-u:\b)/ : Token; +/* 96 */ SignedTerm: /(?-u:\b)signed(?-u:\b)/ : Token; +/* 97 */ StepTerm: /(?-u:\b)step(?-u:\b)/ : Token; +/* 98 */ StringTerm: /(?-u:\b)string(?-u:\b)/ : Token; +/* 99 */ StructTerm: /(?-u:\b)struct(?-u:\b)/ : Token; +/* 100 */ TriTerm: /(?-u:\b)tri(?-u:\b)/ : Token; +/* 101 */ TypeTerm: /(?-u:\b)type(?-u:\b)/ : Token; +/* 102 */ U32Term: /(?-u:\b)u32(?-u:\b)/ : Token; +/* 103 */ U64Term: /(?-u:\b)u64(?-u:\b)/ : Token; +/* 104 */ UnionTerm: /(?-u:\b)union(?-u:\b)/ : Token; +/* 105 */ VarTerm: /(?-u:\b)var(?-u:\b)/ : Token; +/* 106 */ DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; +/* 107 */ IdentifierTerm: /[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; +/* 108 */ AnyTerm: /[^{}]*/ : Token; +/* 109 */ Comments: CommentsOpt /* Option */; +/* 110 */ CommentsOpt /* Option::Some */: CommentsTerm; +/* 111 */ CommentsOpt /* Option::None */: ; +/* 112 */ StartToken: Comments; +/* 113 */ StringLiteralToken: StringLiteralTerm : Token Comments; +/* 114 */ ExponentToken: ExponentTerm : Token Comments; +/* 115 */ FixedPointToken: FixedPointTerm : Token Comments; +/* 116 */ BasedToken: BasedTerm : Token Comments; +/* 117 */ BaseLessToken: BaseLessTerm : Token Comments; +/* 118 */ AllBitToken: AllBitTerm : Token Comments; +/* 119 */ AssignmentOperatorToken: AssignmentOperatorTerm : Token Comments; +/* 120 */ Operator01Token: Operator01Term : Token Comments; +/* 121 */ Operator02Token: Operator02Term : Token Comments; +/* 122 */ Operator03Token: Operator03Term : Token Comments; +/* 123 */ Operator04Token: Operator04Term : Token Comments; +/* 124 */ Operator05Token: Operator05Term : Token Comments; +/* 125 */ Operator06Token: Operator06Term : Token Comments; +/* 126 */ Operator07Token: Operator07Term : Token Comments; +/* 127 */ Operator08Token: Operator08Term : Token Comments; +/* 128 */ Operator09Token: Operator09Term : Token Comments; +/* 129 */ Operator10Token: Operator10Term : Token Comments; +/* 130 */ Operator11Token: Operator11Term : Token Comments; +/* 131 */ UnaryOperatorToken: UnaryOperatorTerm : Token Comments; +/* 132 */ ColonToken: ColonTerm : Token Comments; +/* 133 */ ColonColonLAngleToken: ColonColonLAngleTerm : Token Comments; +/* 134 */ ColonColonToken: ColonColonTerm : Token Comments; +/* 135 */ CommaToken: CommaTerm : Token Comments; +/* 136 */ DotDotToken: DotDotTerm : Token Comments; +/* 137 */ DotDotEquToken: DotDotEquTerm : Token Comments; +/* 138 */ DotToken: DotTerm : Token Comments; +/* 139 */ EquToken: EquTerm : Token Comments; +/* 140 */ HashToken: HashTerm : Token Comments; +/* 141 */ QuoteLBraceToken: QuoteLBraceTerm : Token Comments; +/* 142 */ LAngleToken: LAngleTerm : Token Comments; +/* 143 */ LBraceToken: LBraceTerm : Token Comments; +/* 144 */ LBracketToken: LBracketTerm : Token Comments; +/* 145 */ LParenToken: LParenTerm : Token Comments; +/* 146 */ MinusColonToken: MinusColonTerm : Token Comments; +/* 147 */ MinusGTToken: MinusGTTerm : Token Comments; +/* 148 */ PlusColonToken: PlusColonTerm : Token Comments; +/* 149 */ RAngleToken: RAngleTerm : Token Comments; +/* 150 */ RBraceToken: RBraceTerm : Token Comments; +/* 151 */ RBracketToken: RBracketTerm : Token Comments; +/* 152 */ RParenToken: RParenTerm : Token Comments; +/* 153 */ SemicolonToken: SemicolonTerm : Token Comments; +/* 154 */ StarToken: StarTerm : Token Comments; +/* 155 */ AlwaysCombToken: AlwaysCombTerm : Token Comments; +/* 156 */ AlwaysFfToken: AlwaysFfTerm : Token Comments; +/* 157 */ AsToken: AsTerm : Token Comments; +/* 158 */ AssignToken: AssignTerm : Token Comments; +/* 159 */ BitToken: BitTerm : Token Comments; +/* 160 */ CaseToken: CaseTerm : Token Comments; +/* 161 */ ClockToken: ClockTerm : Token Comments; +/* 162 */ ClockPosedgeToken: ClockPosedgeTerm : Token Comments; +/* 163 */ ClockNegedgeToken: ClockNegedgeTerm : Token Comments; +/* 164 */ DefaultToken: DefaultTerm : Token Comments; +/* 165 */ ElseToken: ElseTerm : Token Comments; +/* 166 */ EmbedToken: EmbedTerm : Token Comments; +/* 167 */ EnumToken: EnumTerm : Token Comments; +/* 168 */ ExportToken: ExportTerm : Token Comments; +/* 169 */ F32Token: F32Term : Token Comments; +/* 170 */ F64Token: F64Term : Token Comments; +/* 171 */ FinalToken: FinalTerm : Token Comments; +/* 172 */ ForToken: ForTerm : Token Comments; +/* 173 */ FunctionToken: FunctionTerm : Token Comments; +/* 174 */ I32Token: I32Term : Token Comments; +/* 175 */ I64Token: I64Term : Token Comments; +/* 176 */ IfResetToken: IfResetTerm : Token Comments; +/* 177 */ IfToken: IfTerm : Token Comments; +/* 178 */ ImportToken: ImportTerm : Token Comments; +/* 179 */ IncludeToken: IncludeTerm : Token Comments; +/* 180 */ InitialToken: InitialTerm : Token Comments; +/* 181 */ InoutToken: InoutTerm : Token Comments; +/* 182 */ InputToken: InputTerm : Token Comments; +/* 183 */ InsideToken: InsideTerm : Token Comments; +/* 184 */ InstToken: InstTerm : Token Comments; +/* 185 */ InterfaceToken: InterfaceTerm : Token Comments; +/* 186 */ InToken: InTerm : Token Comments; +/* 187 */ LetToken: LetTerm : Token Comments; +/* 188 */ LocalToken: LocalTerm : Token Comments; +/* 189 */ LogicToken: LogicTerm : Token Comments; +/* 190 */ LsbToken: LsbTerm : Token Comments; +/* 191 */ ModportToken: ModportTerm : Token Comments; +/* 192 */ ModuleToken: ModuleTerm : Token Comments; +/* 193 */ MsbToken: MsbTerm : Token Comments; +/* 194 */ OutputToken: OutputTerm : Token Comments; +/* 195 */ OutsideToken: OutsideTerm : Token Comments; +/* 196 */ PackageToken: PackageTerm : Token Comments; +/* 197 */ ParamToken: ParamTerm : Token Comments; +/* 198 */ PubToken: PubTerm : Token Comments; +/* 199 */ RefToken: RefTerm : Token Comments; +/* 200 */ RepeatToken: RepeatTerm : Token Comments; +/* 201 */ ResetToken: ResetTerm : Token Comments; +/* 202 */ ResetAsyncHighToken: ResetAsyncHighTerm : Token Comments; +/* 203 */ ResetAsyncLowToken: ResetAsyncLowTerm : Token Comments; +/* 204 */ ResetSyncHighToken: ResetSyncHighTerm : Token Comments; +/* 205 */ ResetSyncLowToken: ResetSyncLowTerm : Token Comments; +/* 206 */ ReturnToken: ReturnTerm : Token Comments; +/* 207 */ BreakToken: BreakTerm : Token Comments; +/* 208 */ SignedToken: SignedTerm : Token Comments; +/* 209 */ StepToken: StepTerm : Token Comments; +/* 210 */ StringToken: StringTerm : Token Comments; +/* 211 */ StructToken: StructTerm : Token Comments; +/* 212 */ TriToken: TriTerm : Token Comments; +/* 213 */ TypeToken: TypeTerm : Token Comments; +/* 214 */ U32Token: U32Term : Token Comments; +/* 215 */ U64Token: U64Term : Token Comments; +/* 216 */ UnionToken: UnionTerm : Token Comments; +/* 217 */ VarToken: VarTerm : Token Comments; +/* 218 */ DollarIdentifierToken: DollarIdentifierTerm : Token Comments; +/* 219 */ IdentifierToken: IdentifierTerm : Token Comments; +/* 220 */ Start: StartToken : VerylToken; +/* 221 */ StringLiteral: StringLiteralToken : VerylToken; +/* 222 */ Exponent: ExponentToken : VerylToken; +/* 223 */ FixedPoint: FixedPointToken : VerylToken; +/* 224 */ Based: BasedToken : VerylToken; +/* 225 */ BaseLess: BaseLessToken : VerylToken; +/* 226 */ AllBit: AllBitToken : VerylToken; +/* 227 */ AssignmentOperator: AssignmentOperatorToken : VerylToken; +/* 228 */ Operator01: Operator01Token : VerylToken; +/* 229 */ Operator02: Operator02Token : VerylToken; +/* 230 */ Operator03: Operator03Token : VerylToken; +/* 231 */ Operator04: Operator04Token : VerylToken; +/* 232 */ Operator05: Operator05Token : VerylToken; +/* 233 */ Operator06: Operator06Token : VerylToken; +/* 234 */ Operator07: Operator07Token : VerylToken; +/* 235 */ Operator08: Operator08Token : VerylToken; +/* 236 */ Operator09: Operator09Token : VerylToken; +/* 237 */ Operator10: Operator10Token : VerylToken; +/* 238 */ Operator11: Operator11Token : VerylToken; +/* 239 */ UnaryOperator: UnaryOperatorToken : VerylToken; +/* 240 */ Colon: ColonToken : VerylToken; +/* 241 */ ColonColonLAngle: ColonColonLAngleToken : VerylToken; +/* 242 */ ColonColon: ColonColonToken : VerylToken; +/* 243 */ Comma: CommaToken : VerylToken; +/* 244 */ DotDot: DotDotToken : VerylToken; +/* 245 */ DotDotEqu: DotDotEquToken : VerylToken; +/* 246 */ Dot: DotToken : VerylToken; +/* 247 */ Equ: EquToken : VerylToken; +/* 248 */ Hash: HashToken : VerylToken; +/* 249 */ QuoteLBrace: QuoteLBraceToken : VerylToken; +/* 250 */ LAngle: LAngleToken : VerylToken; +/* 251 */ LBrace: LBraceToken : VerylToken; +/* 252 */ LBracket: LBracketToken : VerylToken; +/* 253 */ LParen: LParenToken : VerylToken; +/* 254 */ MinusColon: MinusColonToken : VerylToken; +/* 255 */ MinusGT: MinusGTToken : VerylToken; +/* 256 */ PlusColon: PlusColonToken : VerylToken; +/* 257 */ RAngle: RAngleToken : VerylToken; +/* 258 */ RBrace: RBraceToken : VerylToken; +/* 259 */ RBracket: RBracketToken : VerylToken; +/* 260 */ RParen: RParenToken : VerylToken; +/* 261 */ Semicolon: SemicolonToken : VerylToken; +/* 262 */ Star: StarToken : VerylToken; +/* 263 */ AlwaysComb: AlwaysCombToken : VerylToken; +/* 264 */ AlwaysFf: AlwaysFfToken : VerylToken; +/* 265 */ As: AsToken : VerylToken; +/* 266 */ Assign: AssignToken : VerylToken; +/* 267 */ Bit: BitToken : VerylToken; +/* 268 */ Break: BreakToken : VerylToken; +/* 269 */ Case: CaseToken : VerylToken; +/* 270 */ Clock: ClockToken : VerylToken; +/* 271 */ ClockPosedge: ClockPosedgeToken : VerylToken; +/* 272 */ ClockNegedge: ClockNegedgeToken : VerylToken; +/* 273 */ Defaul: DefaultToken : VerylToken; +/* 274 */ Else: ElseToken : VerylToken; +/* 275 */ Embed: EmbedToken : VerylToken; +/* 276 */ Enum: EnumToken : VerylToken; +/* 277 */ Export: ExportToken : VerylToken; +/* 278 */ F32: F32Token : VerylToken; +/* 279 */ F64: F64Token : VerylToken; +/* 280 */ Final: FinalToken : VerylToken; +/* 281 */ For: ForToken : VerylToken; +/* 282 */ Function: FunctionToken : VerylToken; +/* 283 */ I32: I32Token : VerylToken; +/* 284 */ I64: I64Token : VerylToken; +/* 285 */ If: IfToken : VerylToken; +/* 286 */ IfReset: IfResetToken : VerylToken; +/* 287 */ Import: ImportToken : VerylToken; +/* 288 */ In: InToken : VerylToken; +/* 289 */ Include: IncludeToken : VerylToken; +/* 290 */ Initial: InitialToken : VerylToken; +/* 291 */ Inout: InoutToken : VerylToken; +/* 292 */ Input: InputToken : VerylToken; +/* 293 */ Inside: InsideToken : VerylToken; +/* 294 */ Inst: InstToken : VerylToken; +/* 295 */ Interface: InterfaceToken : VerylToken; +/* 296 */ Let: LetToken : VerylToken; +/* 297 */ Local: LocalToken : VerylToken; +/* 298 */ Logic: LogicToken : VerylToken; +/* 299 */ Lsb: LsbToken : VerylToken; +/* 300 */ Modport: ModportToken : VerylToken; +/* 301 */ Module: ModuleToken : VerylToken; +/* 302 */ Msb: MsbToken : VerylToken; +/* 303 */ Output: OutputToken : VerylToken; +/* 304 */ Outside: OutsideToken : VerylToken; +/* 305 */ Package: PackageToken : VerylToken; +/* 306 */ Param: ParamToken : VerylToken; +/* 307 */ Pub: PubToken : VerylToken; +/* 308 */ Ref: RefToken : VerylToken; +/* 309 */ Repeat: RepeatToken : VerylToken; +/* 310 */ Reset: ResetToken : VerylToken; +/* 311 */ ResetAsyncHigh: ResetAsyncHighToken : VerylToken; +/* 312 */ ResetAsyncLow: ResetAsyncLowToken : VerylToken; +/* 313 */ ResetSyncHigh: ResetSyncHighToken : VerylToken; +/* 314 */ ResetSyncLow: ResetSyncLowToken : VerylToken; +/* 315 */ Return: ReturnToken : VerylToken; +/* 316 */ Signed: SignedToken : VerylToken; +/* 317 */ Step: StepToken : VerylToken; +/* 318 */ Strin: StringToken : VerylToken; +/* 319 */ Struct: StructToken : VerylToken; +/* 320 */ Tri: TriToken : VerylToken; +/* 321 */ Type: TypeToken : VerylToken; +/* 322 */ U32: U32Token : VerylToken; +/* 323 */ U64: U64Token : VerylToken; +/* 324 */ Union: UnionToken : VerylToken; +/* 325 */ Var: VarToken : VerylToken; +/* 326 */ DollarIdentifier: DollarIdentifierToken : VerylToken; +/* 327 */ Identifier: IdentifierToken : VerylToken; +/* 328 */ Number: IntegralNumber; +/* 329 */ Number: RealNumber; +/* 330 */ IntegralNumber: Based; +/* 331 */ IntegralNumber: BaseLess; +/* 332 */ IntegralNumber: AllBit; +/* 333 */ RealNumber: FixedPoint; +/* 334 */ RealNumber: Exponent; +/* 335 */ HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */; +/* 336 */ HierarchicalIdentifierList0 /* Vec::Push */: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0; +/* 337 */ HierarchicalIdentifierList0List /* Vec::Push */: Select HierarchicalIdentifierList0List; +/* 338 */ HierarchicalIdentifierList0List /* Vec::New */: ; +/* 339 */ HierarchicalIdentifierList0 /* Vec::New */: ; +/* 340 */ HierarchicalIdentifierList /* Vec::Push */: Select HierarchicalIdentifierList; +/* 341 */ HierarchicalIdentifierList /* Vec::New */: ; +/* 342 */ ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */; +/* 343 */ ScopedIdentifierGroup: DollarIdentifier; +/* 344 */ ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */; +/* 345 */ ScopedIdentifierList /* Vec::Push */: ColonColon Identifier ScopedIdentifierOpt0 /* Option */ ScopedIdentifierList; +/* 346 */ ScopedIdentifierList /* Vec::New */: ; +/* 347 */ ScopedIdentifierOpt0 /* Option::Some */: WithGenericArgument; +/* 348 */ ScopedIdentifierOpt0 /* Option::None */: ; +/* 349 */ ScopedIdentifierOpt /* Option::Some */: WithGenericArgument; +/* 350 */ ScopedIdentifierOpt /* Option::None */: ; +/* 351 */ ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */; +/* 352 */ ExpressionIdentifierList0 /* Vec::Push */: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0; +/* 353 */ ExpressionIdentifierList0List /* Vec::Push */: Select ExpressionIdentifierList0List; +/* 354 */ ExpressionIdentifierList0List /* Vec::New */: ; +/* 355 */ ExpressionIdentifierList0 /* Vec::New */: ; +/* 356 */ ExpressionIdentifierList /* Vec::Push */: Select ExpressionIdentifierList; +/* 357 */ ExpressionIdentifierList /* Vec::New */: ; +/* 358 */ Expression: Expression01 ExpressionList /* Vec */; +/* 359 */ ExpressionList /* Vec::Push */: Operator01 Expression01 ExpressionList; +/* 360 */ ExpressionList /* Vec::New */: ; +/* 361 */ Expression01: Expression02 Expression01List /* Vec */; +/* 362 */ Expression01List /* Vec::Push */: Operator02 Expression02 Expression01List; +/* 363 */ Expression01List /* Vec::New */: ; +/* 364 */ Expression02: Expression03 Expression02List /* Vec */; +/* 365 */ Expression02List /* Vec::Push */: Operator03 Expression03 Expression02List; +/* 366 */ Expression02List /* Vec::New */: ; +/* 367 */ Expression03: Expression04 Expression03List /* Vec */; +/* 368 */ Expression03List /* Vec::Push */: Operator04 Expression04 Expression03List; +/* 369 */ Expression03List /* Vec::New */: ; +/* 370 */ Expression04: Expression05 Expression04List /* Vec */; +/* 371 */ Expression04List /* Vec::Push */: Operator05 Expression05 Expression04List; +/* 372 */ Expression04List /* Vec::New */: ; +/* 373 */ Expression05: Expression06 Expression05List /* Vec */; +/* 374 */ Expression05List /* Vec::Push */: Operator06 Expression06 Expression05List; +/* 375 */ Expression05List /* Vec::New */: ; +/* 376 */ Expression06: Expression07 Expression06List /* Vec */; +/* 377 */ Expression06List /* Vec::Push */: Operator07 Expression07 Expression06List; +/* 378 */ Expression06List /* Vec::New */: ; +/* 379 */ Expression07: Expression08 Expression07List /* Vec */; +/* 380 */ Expression07List /* Vec::Push */: Operator08 Expression08 Expression07List; +/* 381 */ Expression07List /* Vec::New */: ; +/* 382 */ Expression08: Expression09 Expression08List /* Vec */; +/* 383 */ Expression08List /* Vec::Push */: Operator09 Expression09 Expression08List; +/* 384 */ Expression08List /* Vec::New */: ; +/* 385 */ Expression09: Expression10 Expression09List /* Vec */; +/* 386 */ Expression09List /* Vec::Push */: Expression09ListGroup Expression10 Expression09List; +/* 387 */ Expression09ListGroup: Operator10; +/* 388 */ Expression09ListGroup: Star; +/* 389 */ Expression09List /* Vec::New */: ; +/* 390 */ Expression10: Expression11 Expression10List /* Vec */; +/* 391 */ Expression10List /* Vec::Push */: Operator11 Expression11 Expression10List; +/* 392 */ Expression10List /* Vec::New */: ; +/* 393 */ Expression11: Expression12 Expression11List /* Vec */; +/* 394 */ Expression11List /* Vec::Push */: As ScopedIdentifier Expression11List; +/* 395 */ Expression11List /* Vec::New */: ; +/* 396 */ Expression12: Expression12List /* Vec */ Factor; +/* 397 */ Expression12List /* Vec::Push */: Expression12ListGroup Expression12List; +/* 398 */ Expression12ListGroup: UnaryOperator; +/* 399 */ Expression12ListGroup: Operator09; +/* 400 */ Expression12ListGroup: Operator05; +/* 401 */ Expression12ListGroup: Operator03; +/* 402 */ Expression12ListGroup: Operator04; +/* 403 */ Expression12List /* Vec::New */: ; +/* 404 */ Factor: Number; +/* 405 */ Factor: ExpressionIdentifier FactorOpt /* Option */; +/* 406 */ Factor: LParen Expression RParen; +/* 407 */ Factor: LBrace ConcatenationList RBrace; +/* 408 */ Factor: QuoteLBrace ArrayLiteralList RBrace; +/* 409 */ Factor: IfExpression; +/* 410 */ Factor: CaseExpression; +/* 411 */ Factor: StringLiteral; +/* 412 */ Factor: FactorGroup; +/* 413 */ FactorGroup: Msb; +/* 414 */ FactorGroup: Lsb; +/* 415 */ Factor: InsideExpression; +/* 416 */ Factor: OutsideExpression; +/* 417 */ FactorOpt /* Option::Some */: FunctionCall; +/* 418 */ FactorOpt /* Option::None */: ; +/* 419 */ FunctionCall: LParen FunctionCallOpt /* Option */ RParen; +/* 420 */ FunctionCallOpt /* Option::Some */: ArgumentList; +/* 421 */ FunctionCallOpt /* Option::None */: ; +/* 422 */ ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */; +/* 423 */ ArgumentListList /* Vec::Push */: Comma ArgumentItem ArgumentListList; +/* 424 */ ArgumentListList /* Vec::New */: ; +/* 425 */ ArgumentListOpt /* Option::Some */: Comma; +/* 426 */ ArgumentListOpt /* Option::None */: ; +/* 427 */ ArgumentItem: Expression; +/* 428 */ ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */; +/* 429 */ ConcatenationListList /* Vec::Push */: Comma ConcatenationItem ConcatenationListList; +/* 430 */ ConcatenationListList /* Vec::New */: ; +/* 431 */ ConcatenationListOpt /* Option::Some */: Comma; +/* 432 */ ConcatenationListOpt /* Option::None */: ; +/* 433 */ ConcatenationItem: Expression ConcatenationItemOpt /* Option */; +/* 434 */ ConcatenationItemOpt /* Option::Some */: Repeat Expression; +/* 435 */ ConcatenationItemOpt /* Option::None */: ; +/* 436 */ ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */; +/* 437 */ ArrayLiteralListList /* Vec::Push */: Comma ArrayLiteralItem ArrayLiteralListList; +/* 438 */ ArrayLiteralListList /* Vec::New */: ; +/* 439 */ ArrayLiteralListOpt /* Option::Some */: Comma; +/* 440 */ ArrayLiteralListOpt /* Option::None */: ; +/* 441 */ ArrayLiteralItem: ArrayLiteralItemGroup; +/* 442 */ ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */; +/* 443 */ ArrayLiteralItemGroup: Defaul Colon Expression; +/* 444 */ ArrayLiteralItemOpt /* Option::Some */: Repeat Expression; +/* 445 */ ArrayLiteralItemOpt /* Option::None */: ; +/* 446 */ IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace; +/* 447 */ IfExpressionList /* Vec::Push */: Else If Expression LBrace Expression RBrace IfExpressionList; +/* 448 */ IfExpressionList /* Vec::New */: ; +/* 449 */ CaseExpression: Case Expression LBrace Expression CaseExpressionList /* Vec */ Colon Expression Comma CaseExpressionList0 /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace; +/* 450 */ CaseExpressionList0 /* Vec::Push */: Expression CaseExpressionList0List /* Vec */ Colon Expression Comma CaseExpressionList0; +/* 451 */ CaseExpressionList0List /* Vec::Push */: Comma Expression CaseExpressionList0List; +/* 452 */ CaseExpressionList0List /* Vec::New */: ; +/* 453 */ CaseExpressionList0 /* Vec::New */: ; +/* 454 */ CaseExpressionList /* Vec::Push */: Comma Expression CaseExpressionList; +/* 455 */ CaseExpressionList /* Vec::New */: ; +/* 456 */ CaseExpressionOpt /* Option::Some */: Comma; +/* 457 */ CaseExpressionOpt /* Option::None */: ; +/* 458 */ TypeExpression: ScalarType; +/* 459 */ TypeExpression: Type LParen Expression RParen; +/* 460 */ InsideExpression: Inside Expression LBrace RangeList RBrace; +/* 461 */ OutsideExpression: Outside Expression LBrace RangeList RBrace; +/* 462 */ RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */; +/* 463 */ RangeListList /* Vec::Push */: Comma RangeItem RangeListList; +/* 464 */ RangeListList /* Vec::New */: ; +/* 465 */ RangeListOpt /* Option::Some */: Comma; +/* 466 */ RangeListOpt /* Option::None */: ; +/* 467 */ RangeItem: Range; +/* 468 */ Select: LBracket Expression SelectOpt /* Option */ RBracket; +/* 469 */ SelectOpt /* Option::Some */: SelectOperator Expression; +/* 470 */ SelectOpt /* Option::None */: ; +/* 471 */ SelectOperator: Colon; +/* 472 */ SelectOperator: PlusColon; +/* 473 */ SelectOperator: MinusColon; +/* 474 */ SelectOperator: Step; +/* 475 */ Width: LAngle Expression WidthList /* Vec */ RAngle; +/* 476 */ WidthList /* Vec::Push */: Comma Expression WidthList; +/* 477 */ WidthList /* Vec::New */: ; +/* 478 */ Array: LBracket Expression ArrayList /* Vec */ RBracket; +/* 479 */ ArrayList /* Vec::Push */: Comma Expression ArrayList; +/* 480 */ ArrayList /* Vec::New */: ; +/* 481 */ Range: Expression RangeOpt /* Option */; +/* 482 */ RangeOpt /* Option::Some */: RangeOperator Expression; +/* 483 */ RangeOpt /* Option::None */: ; +/* 484 */ RangeOperator: DotDot; +/* 485 */ RangeOperator: DotDotEqu; +/* 486 */ FixedType: U32; +/* 487 */ FixedType: U64; +/* 488 */ FixedType: I32; +/* 489 */ FixedType: I64; +/* 490 */ FixedType: F32; +/* 491 */ FixedType: F64; +/* 492 */ FixedType: Strin; +/* 493 */ VariableType: VariableTypeGroup VariableTypeOpt /* Option */; +/* 494 */ VariableTypeGroup: Clock; +/* 495 */ VariableTypeGroup: ClockPosedge; +/* 496 */ VariableTypeGroup: ClockNegedge; +/* 497 */ VariableTypeGroup: Reset; +/* 498 */ VariableTypeGroup: ResetAsyncHigh; +/* 499 */ VariableTypeGroup: ResetAsyncLow; +/* 500 */ VariableTypeGroup: ResetSyncHigh; +/* 501 */ VariableTypeGroup: ResetSyncLow; +/* 502 */ VariableTypeGroup: Logic; +/* 503 */ VariableTypeGroup: Bit; +/* 504 */ VariableTypeGroup: ScopedIdentifier; +/* 505 */ VariableTypeOpt /* Option::Some */: Width; +/* 506 */ VariableTypeOpt /* Option::None */: ; +/* 507 */ TypeModifier: Tri; +/* 508 */ TypeModifier: Signed; +/* 509 */ ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup; +/* 510 */ ScalarTypeGroup: VariableType; +/* 511 */ ScalarTypeGroup: FixedType; +/* 512 */ ScalarTypeList /* Vec::Push */: TypeModifier ScalarTypeList; +/* 513 */ ScalarTypeList /* Vec::New */: ; +/* 514 */ ArrayType: ScalarType ArrayTypeOpt /* Option */; +/* 515 */ ArrayTypeOpt /* Option::Some */: Array; +/* 516 */ ArrayTypeOpt /* Option::None */: ; +/* 517 */ Statement: LetStatement; +/* 518 */ Statement: IdentifierStatement; +/* 519 */ Statement: IfStatement; +/* 520 */ Statement: IfResetStatement; +/* 521 */ Statement: ReturnStatement; +/* 522 */ Statement: BreakStatement; +/* 523 */ Statement: ForStatement; +/* 524 */ Statement: CaseStatement; +/* 525 */ LetStatement: Let Identifier Colon ArrayType Equ Expression Semicolon; +/* 526 */ IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon; +/* 527 */ IdentifierStatementGroup: FunctionCall; +/* 528 */ IdentifierStatementGroup: Assignment; +/* 529 */ Assignment: AssignmentGroup Expression; +/* 530 */ AssignmentGroup: Equ; +/* 531 */ AssignmentGroup: AssignmentOperator; +/* 532 */ IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */; +/* 533 */ IfStatementList0 /* Vec::Push */: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0; +/* 534 */ IfStatementList0List /* Vec::Push */: Statement IfStatementList0List; +/* 535 */ IfStatementList0List /* Vec::New */: ; +/* 536 */ IfStatementList0 /* Vec::New */: ; +/* 537 */ IfStatementList /* Vec::Push */: Statement IfStatementList; +/* 538 */ IfStatementList /* Vec::New */: ; +/* 539 */ IfStatementOpt /* Option::Some */: Else LBrace IfStatementOptList /* Vec */ RBrace; +/* 540 */ IfStatementOptList /* Vec::Push */: Statement IfStatementOptList; +/* 541 */ IfStatementOptList /* Vec::New */: ; +/* 542 */ IfStatementOpt /* Option::None */: ; +/* 543 */ IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */; +/* 544 */ IfResetStatementList0 /* Vec::Push */: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0; +/* 545 */ IfResetStatementList0List /* Vec::Push */: Statement IfResetStatementList0List; +/* 546 */ IfResetStatementList0List /* Vec::New */: ; +/* 547 */ IfResetStatementList0 /* Vec::New */: ; +/* 548 */ IfResetStatementList /* Vec::Push */: Statement IfResetStatementList; +/* 549 */ IfResetStatementList /* Vec::New */: ; +/* 550 */ IfResetStatementOpt /* Option::Some */: Else LBrace IfResetStatementOptList /* Vec */ RBrace; +/* 551 */ IfResetStatementOptList /* Vec::Push */: Statement IfResetStatementOptList; +/* 552 */ IfResetStatementOptList /* Vec::New */: ; +/* 553 */ IfResetStatementOpt /* Option::None */: ; +/* 554 */ ReturnStatement: Return Expression Semicolon; +/* 555 */ BreakStatement: Break Semicolon; +/* 556 */ ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace; +/* 557 */ ForStatementList /* Vec::Push */: Statement ForStatementList; +/* 558 */ ForStatementList /* Vec::New */: ; +/* 559 */ ForStatementOpt /* Option::Some */: Step AssignmentOperator Expression; +/* 560 */ ForStatementOpt /* Option::None */: ; +/* 561 */ CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace; +/* 562 */ CaseStatementList /* Vec::Push */: CaseItem CaseStatementList; +/* 563 */ CaseStatementList /* Vec::New */: ; +/* 564 */ CaseItem: CaseItemGroup Colon CaseItemGroup0; +/* 565 */ CaseItemGroup0: Statement; +/* 566 */ CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace; +/* 567 */ CaseItemGroup0List /* Vec::Push */: Statement CaseItemGroup0List; +/* 568 */ CaseItemGroup0List /* Vec::New */: ; +/* 569 */ CaseItemGroup: Expression CaseItemGroupList /* Vec */; +/* 570 */ CaseItemGroupList /* Vec::Push */: Comma Expression CaseItemGroupList; +/* 571 */ CaseItemGroupList /* Vec::New */: ; +/* 572 */ CaseItemGroup: Defaul; +/* 573 */ Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket; +/* 574 */ AttributeOpt /* Option::Some */: LParen AttributeList RParen; +/* 575 */ AttributeOpt /* Option::None */: ; +/* 576 */ AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */; +/* 577 */ AttributeListList /* Vec::Push */: Comma AttributeItem AttributeListList; +/* 578 */ AttributeListList /* Vec::New */: ; +/* 579 */ AttributeListOpt /* Option::Some */: Comma; +/* 580 */ AttributeListOpt /* Option::None */: ; +/* 581 */ AttributeItem: Identifier; +/* 582 */ AttributeItem: StringLiteral; +/* 583 */ LetDeclaration: Let Identifier Colon ArrayType Equ Expression Semicolon; +/* 584 */ VarDeclaration: Var Identifier Colon ArrayType Semicolon; +/* 585 */ LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon; +/* 586 */ LocalDeclarationGroup: ArrayType Equ Expression; +/* 587 */ LocalDeclarationGroup: Type Equ TypeExpression; +/* 588 */ TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon; +/* 589 */ AlwaysFfDeclaration: AlwaysFf LParen AlwaysFfClock AlwaysFfDeclarationOpt /* Option */ RParen LBrace AlwaysFfDeclarationList /* Vec */ RBrace; +/* 590 */ AlwaysFfDeclarationList /* Vec::Push */: Statement AlwaysFfDeclarationList; +/* 591 */ AlwaysFfDeclarationList /* Vec::New */: ; +/* 592 */ AlwaysFfDeclarationOpt /* Option::Some */: Comma AlwaysFfReset; +/* 593 */ AlwaysFfDeclarationOpt /* Option::None */: ; +/* 594 */ AlwaysFfClock: HierarchicalIdentifier; +/* 595 */ AlwaysFfReset: HierarchicalIdentifier; +/* 596 */ AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace; +/* 597 */ AlwaysCombDeclarationList /* Vec::Push */: Statement AlwaysCombDeclarationList; +/* 598 */ AlwaysCombDeclarationList /* Vec::New */: ; +/* 599 */ AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon; +/* 600 */ ModportDeclaration: Modport Identifier LBrace ModportList RBrace; +/* 601 */ ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */; +/* 602 */ ModportListList /* Vec::Push */: Comma ModportGroup ModportListList; +/* 603 */ ModportListList /* Vec::New */: ; +/* 604 */ ModportListOpt /* Option::Some */: Comma; +/* 605 */ ModportListOpt /* Option::None */: ; +/* 606 */ ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup; +/* 607 */ ModportGroupGroup: LBrace ModportList RBrace; +/* 608 */ ModportGroupGroup: ModportItem; +/* 609 */ ModportGroupList /* Vec::Push */: Attribute ModportGroupList; +/* 610 */ ModportGroupList /* Vec::New */: ; +/* 611 */ ModportItem: Identifier Colon Direction; +/* 612 */ EnumDeclaration: Enum Identifier Colon ScalarType LBrace EnumList RBrace; +/* 613 */ EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */; +/* 614 */ EnumListList /* Vec::Push */: Comma EnumGroup EnumListList; +/* 615 */ EnumListList /* Vec::New */: ; +/* 616 */ EnumListOpt /* Option::Some */: Comma; +/* 617 */ EnumListOpt /* Option::None */: ; +/* 618 */ EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup; +/* 619 */ EnumGroupGroup: LBrace EnumList RBrace; +/* 620 */ EnumGroupGroup: EnumItem; +/* 621 */ EnumGroupList /* Vec::Push */: Attribute EnumGroupList; +/* 622 */ EnumGroupList /* Vec::New */: ; +/* 623 */ EnumItem: Identifier EnumItemOpt /* Option */; +/* 624 */ EnumItemOpt /* Option::Some */: Equ Expression; +/* 625 */ EnumItemOpt /* Option::None */: ; +/* 626 */ StructUnion: Struct; +/* 627 */ StructUnion: Union; +/* 628 */ StructUnionDeclaration: StructUnion Identifier StructUnionDeclarationOpt /* Option */ LBrace StructUnionList RBrace; +/* 629 */ StructUnionDeclarationOpt /* Option::Some */: WithGenericParameter; +/* 630 */ StructUnionDeclarationOpt /* Option::None */: ; +/* 631 */ StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */; +/* 632 */ StructUnionListList /* Vec::Push */: Comma StructUnionGroup StructUnionListList; +/* 633 */ StructUnionListList /* Vec::New */: ; +/* 634 */ StructUnionListOpt /* Option::Some */: Comma; +/* 635 */ StructUnionListOpt /* Option::None */: ; +/* 636 */ StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup; +/* 637 */ StructUnionGroupGroup: LBrace StructUnionList RBrace; +/* 638 */ StructUnionGroupGroup: StructUnionItem; +/* 639 */ StructUnionGroupList /* Vec::Push */: Attribute StructUnionGroupList; +/* 640 */ StructUnionGroupList /* Vec::New */: ; +/* 641 */ StructUnionItem: Identifier Colon ScalarType; +/* 642 */ InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace; +/* 643 */ InitialDeclarationList /* Vec::Push */: Statement InitialDeclarationList; +/* 644 */ InitialDeclarationList /* Vec::New */: ; +/* 645 */ FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace; +/* 646 */ FinalDeclarationList /* Vec::Push */: Statement FinalDeclarationList; +/* 647 */ FinalDeclarationList /* Vec::New */: ; +/* 648 */ InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon; +/* 649 */ InstDeclarationOpt1 /* Option::Some */: LParen InstDeclarationOpt2 /* Option */ RParen; +/* 650 */ InstDeclarationOpt2 /* Option::Some */: InstPortList; +/* 651 */ InstDeclarationOpt2 /* Option::None */: ; +/* 652 */ InstDeclarationOpt1 /* Option::None */: ; +/* 653 */ InstDeclarationOpt0 /* Option::Some */: InstParameter; +/* 654 */ InstDeclarationOpt0 /* Option::None */: ; +/* 655 */ InstDeclarationOpt /* Option::Some */: Array; +/* 656 */ InstDeclarationOpt /* Option::None */: ; +/* 657 */ InstParameter: Hash LParen InstParameterOpt /* Option */ RParen; +/* 658 */ InstParameterOpt /* Option::Some */: InstParameterList; +/* 659 */ InstParameterOpt /* Option::None */: ; +/* 660 */ InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */; +/* 661 */ InstParameterListList /* Vec::Push */: Comma InstParameterGroup InstParameterListList; +/* 662 */ InstParameterListList /* Vec::New */: ; +/* 663 */ InstParameterListOpt /* Option::Some */: Comma; +/* 664 */ InstParameterListOpt /* Option::None */: ; +/* 665 */ InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup; +/* 666 */ InstParameterGroupGroup: LBrace InstParameterList RBrace; +/* 667 */ InstParameterGroupGroup: InstParameterItem; +/* 668 */ InstParameterGroupList /* Vec::Push */: Attribute InstParameterGroupList; +/* 669 */ InstParameterGroupList /* Vec::New */: ; +/* 670 */ InstParameterItem: Identifier InstParameterItemOpt /* Option */; +/* 671 */ InstParameterItemOpt /* Option::Some */: Colon Expression; +/* 672 */ InstParameterItemOpt /* Option::None */: ; +/* 673 */ InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */; +/* 674 */ InstPortListList /* Vec::Push */: Comma InstPortGroup InstPortListList; +/* 675 */ InstPortListList /* Vec::New */: ; +/* 676 */ InstPortListOpt /* Option::Some */: Comma; +/* 677 */ InstPortListOpt /* Option::None */: ; +/* 678 */ InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup; +/* 679 */ InstPortGroupGroup: LBrace InstPortList RBrace; +/* 680 */ InstPortGroupGroup: InstPortItem; +/* 681 */ InstPortGroupList /* Vec::Push */: Attribute InstPortGroupList; +/* 682 */ InstPortGroupList /* Vec::New */: ; +/* 683 */ InstPortItem: Identifier InstPortItemOpt /* Option */; +/* 684 */ InstPortItemOpt /* Option::Some */: Colon Expression; +/* 685 */ InstPortItemOpt /* Option::None */: ; +/* 686 */ WithParameter: Hash LParen WithParameterOpt /* Option */ RParen; +/* 687 */ WithParameterOpt /* Option::Some */: WithParameterList; +/* 688 */ WithParameterOpt /* Option::None */: ; +/* 689 */ WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */; +/* 690 */ WithParameterListList /* Vec::Push */: Comma WithParameterGroup WithParameterListList; +/* 691 */ WithParameterListList /* Vec::New */: ; +/* 692 */ WithParameterListOpt /* Option::Some */: Comma; +/* 693 */ WithParameterListOpt /* Option::None */: ; +/* 694 */ WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup; +/* 695 */ WithParameterGroupGroup: LBrace WithParameterList RBrace; +/* 696 */ WithParameterGroupGroup: WithParameterItem; +/* 697 */ WithParameterGroupList /* Vec::Push */: Attribute WithParameterGroupList; +/* 698 */ WithParameterGroupList /* Vec::New */: ; +/* 699 */ WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0; +/* 700 */ WithParameterItemGroup0: ArrayType Equ Expression; +/* 701 */ WithParameterItemGroup0: Type Equ TypeExpression; +/* 702 */ WithParameterItemGroup: Param; +/* 703 */ WithParameterItemGroup: Local; +/* 704 */ WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle; +/* 705 */ WithGenericParameterList: WithGenericParameterItem WithGenericParameterListList /* Vec */ WithGenericParameterListOpt /* Option */; +/* 706 */ WithGenericParameterListList /* Vec::Push */: Comma WithGenericParameterItem WithGenericParameterListList; +/* 707 */ WithGenericParameterListList /* Vec::New */: ; +/* 708 */ WithGenericParameterListOpt /* Option::Some */: Comma; +/* 709 */ WithGenericParameterListOpt /* Option::None */: ; +/* 710 */ WithGenericParameterItem: Identifier; +/* 711 */ WithGenericArgument: ColonColonLAngle %push(Generic) WithGenericArgumentList RAngle %pop(); +/* 712 */ WithGenericArgumentList: WithGenericArgumentItem WithGenericArgumentListList /* Vec */ WithGenericArgumentListOpt /* Option */; +/* 713 */ WithGenericArgumentListList /* Vec::Push */: Comma WithGenericArgumentItem WithGenericArgumentListList; +/* 714 */ WithGenericArgumentListList /* Vec::New */: ; +/* 715 */ WithGenericArgumentListOpt /* Option::Some */: Comma; +/* 716 */ WithGenericArgumentListOpt /* Option::None */: ; +/* 717 */ WithGenericArgumentItem: ScopedIdentifier; +/* 718 */ WithGenericArgumentItem: Number; +/* 719 */ PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen; +/* 720 */ PortDeclarationOpt /* Option::Some */: PortDeclarationList; +/* 721 */ PortDeclarationOpt /* Option::None */: ; +/* 722 */ PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */; +/* 723 */ PortDeclarationListList /* Vec::Push */: Comma PortDeclarationGroup PortDeclarationListList; +/* 724 */ PortDeclarationListList /* Vec::New */: ; +/* 725 */ PortDeclarationListOpt /* Option::Some */: Comma; +/* 726 */ PortDeclarationListOpt /* Option::None */: ; +/* 727 */ PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup; +/* 728 */ PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace; +/* 729 */ PortDeclarationGroupGroup: PortDeclarationItem; +/* 730 */ PortDeclarationGroupList /* Vec::Push */: Attribute PortDeclarationGroupList; +/* 731 */ PortDeclarationGroupList /* Vec::New */: ; +/* 732 */ PortDeclarationItem: Identifier Colon PortDeclarationItemGroup; +/* 733 */ PortDeclarationItemGroup: Direction ArrayType; +/* 734 */ PortDeclarationItemGroup: Interface PortDeclarationItemOpt /* Option */; +/* 735 */ PortDeclarationItemOpt /* Option::Some */: Array; +/* 736 */ PortDeclarationItemOpt /* Option::None */: ; +/* 737 */ Direction: Input; +/* 738 */ Direction: Output; +/* 739 */ Direction: Inout; +/* 740 */ Direction: Ref; +/* 741 */ Direction: Modport; +/* 742 */ FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ FunctionDeclarationOpt1 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace; +/* 743 */ FunctionDeclarationList /* Vec::Push */: FunctionItem FunctionDeclarationList; +/* 744 */ FunctionDeclarationList /* Vec::New */: ; +/* 745 */ FunctionDeclarationOpt1 /* Option::Some */: MinusGT ScalarType; +/* 746 */ FunctionDeclarationOpt1 /* Option::None */: ; +/* 747 */ FunctionDeclarationOpt0 /* Option::Some */: PortDeclaration; +/* 748 */ FunctionDeclarationOpt0 /* Option::None */: ; +/* 749 */ FunctionDeclarationOpt /* Option::Some */: WithGenericParameter; +/* 750 */ FunctionDeclarationOpt /* Option::None */: ; +/* 751 */ FunctionItem: VarDeclaration; +/* 752 */ FunctionItem: Statement; +/* 753 */ ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon; +/* 754 */ ImportDeclarationOpt /* Option::Some */: ColonColon Star; +/* 755 */ ImportDeclarationOpt /* Option::None */: ; +/* 756 */ ExportDeclaration: Export ExportDeclarationGroup Semicolon; +/* 757 */ ExportDeclarationGroup: Star; +/* 758 */ ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */; +/* 759 */ ExportDeclarationOpt /* Option::Some */: ColonColon Star; +/* 760 */ ExportDeclarationOpt /* Option::None */: ; +/* 761 */ ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ ModuleDeclarationOpt2 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace; +/* 762 */ ModuleDeclarationList /* Vec::Push */: ModuleGroup ModuleDeclarationList; +/* 763 */ ModuleDeclarationList /* Vec::New */: ; +/* 764 */ ModuleDeclarationOpt2 /* Option::Some */: PortDeclaration; +/* 765 */ ModuleDeclarationOpt2 /* Option::None */: ; +/* 766 */ ModuleDeclarationOpt1 /* Option::Some */: WithParameter; +/* 767 */ ModuleDeclarationOpt1 /* Option::None */: ; +/* 768 */ ModuleDeclarationOpt0 /* Option::Some */: WithGenericParameter; +/* 769 */ ModuleDeclarationOpt0 /* Option::None */: ; +/* 770 */ ModuleDeclarationOpt /* Option::Some */: Pub; +/* 771 */ ModuleDeclarationOpt /* Option::None */: ; +/* 772 */ ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */; +/* 773 */ ModuleIfDeclarationList /* Vec::Push */: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList; +/* 774 */ ModuleIfDeclarationList /* Vec::New */: ; +/* 775 */ ModuleIfDeclarationOpt /* Option::Some */: Else ModuleOptionalNamedBlock; +/* 776 */ ModuleIfDeclarationOpt /* Option::None */: ; +/* 777 */ ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock; +/* 778 */ ModuleForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression; +/* 779 */ ModuleForDeclarationOpt /* Option::None */: ; +/* 780 */ ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace; +/* 781 */ ModuleNamedBlockList /* Vec::Push */: ModuleGroup ModuleNamedBlockList; +/* 782 */ ModuleNamedBlockList /* Vec::New */: ; +/* 783 */ ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace; +/* 784 */ ModuleOptionalNamedBlockList /* Vec::Push */: ModuleGroup ModuleOptionalNamedBlockList; +/* 785 */ ModuleOptionalNamedBlockList /* Vec::New */: ; +/* 786 */ ModuleOptionalNamedBlockOpt /* Option::Some */: Colon Identifier; +/* 787 */ ModuleOptionalNamedBlockOpt /* Option::None */: ; +/* 788 */ ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup; +/* 789 */ ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace; +/* 790 */ ModuleGroupGroupList /* Vec::Push */: ModuleGroup ModuleGroupGroupList; +/* 791 */ ModuleGroupGroupList /* Vec::New */: ; +/* 792 */ ModuleGroupGroup: ModuleItem; +/* 793 */ ModuleGroupList /* Vec::Push */: Attribute ModuleGroupList; +/* 794 */ ModuleGroupList /* Vec::New */: ; +/* 795 */ ModuleItem: LetDeclaration; +/* 796 */ ModuleItem: VarDeclaration; +/* 797 */ ModuleItem: InstDeclaration; +/* 798 */ ModuleItem: TypeDefDeclaration; +/* 799 */ ModuleItem: LocalDeclaration; +/* 800 */ ModuleItem: AlwaysFfDeclaration; +/* 801 */ ModuleItem: AlwaysCombDeclaration; +/* 802 */ ModuleItem: AssignDeclaration; +/* 803 */ ModuleItem: FunctionDeclaration; +/* 804 */ ModuleItem: ModuleIfDeclaration; +/* 805 */ ModuleItem: ModuleForDeclaration; +/* 806 */ ModuleItem: EnumDeclaration; +/* 807 */ ModuleItem: StructUnionDeclaration; +/* 808 */ ModuleItem: ModuleNamedBlock; +/* 809 */ ModuleItem: ImportDeclaration; +/* 810 */ ModuleItem: InitialDeclaration; +/* 811 */ ModuleItem: FinalDeclaration; +/* 812 */ InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ InterfaceDeclarationOpt1 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace; +/* 813 */ InterfaceDeclarationList /* Vec::Push */: InterfaceGroup InterfaceDeclarationList; +/* 814 */ InterfaceDeclarationList /* Vec::New */: ; +/* 815 */ InterfaceDeclarationOpt1 /* Option::Some */: WithParameter; +/* 816 */ InterfaceDeclarationOpt1 /* Option::None */: ; +/* 817 */ InterfaceDeclarationOpt0 /* Option::Some */: WithGenericParameter; +/* 818 */ InterfaceDeclarationOpt0 /* Option::None */: ; +/* 819 */ InterfaceDeclarationOpt /* Option::Some */: Pub; +/* 820 */ InterfaceDeclarationOpt /* Option::None */: ; +/* 821 */ InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */; +/* 822 */ InterfaceIfDeclarationList /* Vec::Push */: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList; +/* 823 */ InterfaceIfDeclarationList /* Vec::New */: ; +/* 824 */ InterfaceIfDeclarationOpt /* Option::Some */: Else InterfaceOptionalNamedBlock; +/* 825 */ InterfaceIfDeclarationOpt /* Option::None */: ; +/* 826 */ InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock; +/* 827 */ InterfaceForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression; +/* 828 */ InterfaceForDeclarationOpt /* Option::None */: ; +/* 829 */ InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace; +/* 830 */ InterfaceNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceNamedBlockList; +/* 831 */ InterfaceNamedBlockList /* Vec::New */: ; +/* 832 */ InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace; +/* 833 */ InterfaceOptionalNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceOptionalNamedBlockList; +/* 834 */ InterfaceOptionalNamedBlockList /* Vec::New */: ; +/* 835 */ InterfaceOptionalNamedBlockOpt /* Option::Some */: Colon Identifier; +/* 836 */ InterfaceOptionalNamedBlockOpt /* Option::None */: ; +/* 837 */ InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup; +/* 838 */ InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace; +/* 839 */ InterfaceGroupGroupList /* Vec::Push */: InterfaceGroup InterfaceGroupGroupList; +/* 840 */ InterfaceGroupGroupList /* Vec::New */: ; +/* 841 */ InterfaceGroupGroup: InterfaceItem; +/* 842 */ InterfaceGroupList /* Vec::Push */: Attribute InterfaceGroupList; +/* 843 */ InterfaceGroupList /* Vec::New */: ; +/* 844 */ InterfaceItem: LetDeclaration; +/* 845 */ InterfaceItem: VarDeclaration; +/* 846 */ InterfaceItem: LocalDeclaration; +/* 847 */ InterfaceItem: ModportDeclaration; +/* 848 */ InterfaceItem: InterfaceIfDeclaration; +/* 849 */ InterfaceItem: InterfaceForDeclaration; +/* 850 */ InterfaceItem: TypeDefDeclaration; +/* 851 */ InterfaceItem: EnumDeclaration; +/* 852 */ InterfaceItem: StructUnionDeclaration; +/* 853 */ InterfaceItem: InterfaceNamedBlock; +/* 854 */ InterfaceItem: FunctionDeclaration; +/* 855 */ InterfaceItem: ImportDeclaration; +/* 856 */ InterfaceItem: InitialDeclaration; +/* 857 */ InterfaceItem: FinalDeclaration; +/* 858 */ PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier PackageDeclarationOpt0 /* Option */ LBrace PackageDeclarationList /* Vec */ RBrace; +/* 859 */ PackageDeclarationList /* Vec::Push */: PackageGroup PackageDeclarationList; +/* 860 */ PackageDeclarationList /* Vec::New */: ; +/* 861 */ PackageDeclarationOpt0 /* Option::Some */: WithGenericParameter; +/* 862 */ PackageDeclarationOpt0 /* Option::None */: ; +/* 863 */ PackageDeclarationOpt /* Option::Some */: Pub; +/* 864 */ PackageDeclarationOpt /* Option::None */: ; +/* 865 */ PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup; +/* 866 */ PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace; +/* 867 */ PackageGroupGroupList /* Vec::Push */: PackageGroup PackageGroupGroupList; +/* 868 */ PackageGroupGroupList /* Vec::New */: ; +/* 869 */ PackageGroupGroup: PackageItem; +/* 870 */ PackageGroupList /* Vec::Push */: Attribute PackageGroupList; +/* 871 */ PackageGroupList /* Vec::New */: ; +/* 872 */ PackageItem: VarDeclaration; +/* 873 */ PackageItem: LocalDeclaration; +/* 874 */ PackageItem: TypeDefDeclaration; +/* 875 */ PackageItem: EnumDeclaration; +/* 876 */ PackageItem: StructUnionDeclaration; +/* 877 */ PackageItem: FunctionDeclaration; +/* 878 */ PackageItem: ImportDeclaration; +/* 879 */ PackageItem: ExportDeclaration; +/* 880 */ PackageItem: InitialDeclaration; +/* 881 */ PackageItem: FinalDeclaration; +/* 882 */ EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent; +/* 883 */ EmbedContent: EmbedContentToken : VerylToken; +/* 884 */ EmbedContentToken: LBraceTerm %push(Embed) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm %pop(); +/* 885 */ EmbedContentTokenList /* Vec::Push */: EmbedItem EmbedContentTokenList; +/* 886 */ EmbedContentTokenList /* Vec::New */: ; +/* 887 */ EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm; +/* 888 */ EmbedItemList /* Vec::Push */: EmbedItem EmbedItemList; +/* 889 */ EmbedItemList /* Vec::New */: ; +/* 890 */ EmbedItem: AnyTerm; +/* 891 */ IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon; +/* 892 */ DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup; +/* 893 */ DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace; +/* 894 */ DescriptionGroupGroupList /* Vec::Push */: DescriptionGroup DescriptionGroupGroupList; +/* 895 */ DescriptionGroupGroupList /* Vec::New */: ; +/* 896 */ DescriptionGroupGroup: DescriptionItem; +/* 897 */ DescriptionGroupList /* Vec::Push */: Attribute DescriptionGroupList; +/* 898 */ DescriptionGroupList /* Vec::New */: ; +/* 899 */ DescriptionItem: ModuleDeclaration; +/* 900 */ DescriptionItem: InterfaceDeclaration; +/* 901 */ DescriptionItem: PackageDeclaration; +/* 902 */ DescriptionItem: ImportDeclaration; +/* 903 */ DescriptionItem: EmbedDeclaration; +/* 904 */ DescriptionItem: IncludeDeclaration; +/* 905 */ Veryl: Start VerylList /* Vec */; +/* 906 */ VerylList /* Vec::Push */: DescriptionGroup VerylList; +/* 907 */ VerylList /* Vec::New */: ; diff --git a/crates/parser/src/generated/veryl_grammar_trait.rs b/crates/parser/src/generated/veryl_grammar_trait.rs index bb3248b0..ec74a8c6 100644 --- a/crates/parser/src/generated/veryl_grammar_trait.rs +++ b/crates/parser/src/generated/veryl_grammar_trait.rs @@ -135,6 +135,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'ColonColonLAngleTerm' + fn colon_colon_l_angle_term(&mut self, _arg: &ColonColonLAngleTerm) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'ColonColonTerm' fn colon_colon_term(&mut self, _arg: &ColonColonTerm) -> Result<()> { Ok(()) @@ -670,6 +675,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'ColonColonLAngleToken' + fn colon_colon_l_angle_token(&mut self, _arg: &ColonColonLAngleToken) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'ColonColonToken' fn colon_colon_token(&mut self, _arg: &ColonColonToken) -> Result<()> { Ok(()) @@ -1205,6 +1215,11 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'ColonColonLAngle' + fn colon_colon_l_angle(&mut self, _arg: &ColonColonLAngle) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'ColonColon' fn colon_colon(&mut self, _arg: &ColonColon) -> Result<()> { Ok(()) @@ -2110,6 +2125,36 @@ pub trait VerylGrammarTrait { Ok(()) } + /// Semantic action for non-terminal 'WithGenericParameter' + fn with_generic_parameter(&mut self, _arg: &WithGenericParameter) -> Result<()> { + Ok(()) + } + + /// Semantic action for non-terminal 'WithGenericParameterList' + fn with_generic_parameter_list(&mut self, _arg: &WithGenericParameterList) -> Result<()> { + Ok(()) + } + + /// Semantic action for non-terminal 'WithGenericParameterItem' + fn with_generic_parameter_item(&mut self, _arg: &WithGenericParameterItem) -> Result<()> { + Ok(()) + } + + /// Semantic action for non-terminal 'WithGenericArgument' + fn with_generic_argument(&mut self, _arg: &WithGenericArgument) -> Result<()> { + Ok(()) + } + + /// Semantic action for non-terminal 'WithGenericArgumentList' + fn with_generic_argument_list(&mut self, _arg: &WithGenericArgumentList) -> Result<()> { + Ok(()) + } + + /// Semantic action for non-terminal 'WithGenericArgumentItem' + fn with_generic_argument_item(&mut self, _arg: &WithGenericArgumentItem) -> Result<()> { + Ok(()) + } + /// Semantic action for non-terminal 'PortDeclaration' fn port_declaration(&mut self, _arg: &PortDeclaration) -> Result<()> { Ok(()) @@ -2291,7 +2336,7 @@ pub trait VerylGrammarTrait { // /// -/// Type derived for production 325 +/// Type derived for production 328 /// /// `Number: IntegralNumber;` /// @@ -2303,7 +2348,7 @@ pub struct NumberIntegralNumber { } /// -/// Type derived for production 326 +/// Type derived for production 329 /// /// `Number: RealNumber;` /// @@ -2315,7 +2360,7 @@ pub struct NumberRealNumber { } /// -/// Type derived for production 327 +/// Type derived for production 330 /// /// `IntegralNumber: Based;` /// @@ -2327,7 +2372,7 @@ pub struct IntegralNumberBased { } /// -/// Type derived for production 328 +/// Type derived for production 331 /// /// `IntegralNumber: BaseLess;` /// @@ -2339,7 +2384,7 @@ pub struct IntegralNumberBaseLess { } /// -/// Type derived for production 329 +/// Type derived for production 332 /// /// `IntegralNumber: AllBit;` /// @@ -2351,7 +2396,7 @@ pub struct IntegralNumberAllBit { } /// -/// Type derived for production 330 +/// Type derived for production 333 /// /// `RealNumber: FixedPoint;` /// @@ -2363,7 +2408,7 @@ pub struct RealNumberFixedPoint { } /// -/// Type derived for production 331 +/// Type derived for production 334 /// /// `RealNumber: Exponent;` /// @@ -2375,7 +2420,7 @@ pub struct RealNumberExponent { } /// -/// Type derived for production 340 +/// Type derived for production 343 /// /// `ScopedIdentifierGroup: DollarIdentifier;` /// @@ -2387,19 +2432,20 @@ pub struct ScopedIdentifierGroupDollarIdentifier { } /// -/// Type derived for production 341 +/// Type derived for production 344 /// -/// `ScopedIdentifierGroup: Identifier;` +/// `ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */;` /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct ScopedIdentifierGroupIdentifier { +pub struct ScopedIdentifierGroupIdentifierScopedIdentifierOpt { pub identifier: Box, + pub scoped_identifier_opt: Option, } /// -/// Type derived for production 380 +/// Type derived for production 387 /// /// `Expression09ListGroup: Operator10;` /// @@ -2411,7 +2457,7 @@ pub struct Expression09ListGroupOperator10 { } /// -/// Type derived for production 381 +/// Type derived for production 388 /// /// `Expression09ListGroup: Star;` /// @@ -2423,7 +2469,7 @@ pub struct Expression09ListGroupStar { } /// -/// Type derived for production 391 +/// Type derived for production 398 /// /// `Expression12ListGroup: UnaryOperator;` /// @@ -2435,7 +2481,7 @@ pub struct Expression12ListGroupUnaryOperator { } /// -/// Type derived for production 392 +/// Type derived for production 399 /// /// `Expression12ListGroup: Operator09;` /// @@ -2447,7 +2493,7 @@ pub struct Expression12ListGroupOperator09 { } /// -/// Type derived for production 393 +/// Type derived for production 400 /// /// `Expression12ListGroup: Operator05;` /// @@ -2459,7 +2505,7 @@ pub struct Expression12ListGroupOperator05 { } /// -/// Type derived for production 394 +/// Type derived for production 401 /// /// `Expression12ListGroup: Operator03;` /// @@ -2471,7 +2517,7 @@ pub struct Expression12ListGroupOperator03 { } /// -/// Type derived for production 395 +/// Type derived for production 402 /// /// `Expression12ListGroup: Operator04;` /// @@ -2483,7 +2529,7 @@ pub struct Expression12ListGroupOperator04 { } /// -/// Type derived for production 397 +/// Type derived for production 404 /// /// `Factor: Number;` /// @@ -2495,7 +2541,7 @@ pub struct FactorNumber { } /// -/// Type derived for production 398 +/// Type derived for production 405 /// /// `Factor: ExpressionIdentifier FactorOpt /* Option */;` /// @@ -2508,7 +2554,7 @@ pub struct FactorExpressionIdentifierFactorOpt { } /// -/// Type derived for production 399 +/// Type derived for production 406 /// /// `Factor: LParen Expression RParen;` /// @@ -2522,7 +2568,7 @@ pub struct FactorLParenExpressionRParen { } /// -/// Type derived for production 400 +/// Type derived for production 407 /// /// `Factor: LBrace ConcatenationList RBrace;` /// @@ -2536,7 +2582,7 @@ pub struct FactorLBraceConcatenationListRBrace { } /// -/// Type derived for production 401 +/// Type derived for production 408 /// /// `Factor: QuoteLBrace ArrayLiteralList RBrace;` /// @@ -2550,7 +2596,7 @@ pub struct FactorQuoteLBraceArrayLiteralListRBrace { } /// -/// Type derived for production 402 +/// Type derived for production 409 /// /// `Factor: IfExpression;` /// @@ -2562,7 +2608,7 @@ pub struct FactorIfExpression { } /// -/// Type derived for production 403 +/// Type derived for production 410 /// /// `Factor: CaseExpression;` /// @@ -2574,7 +2620,7 @@ pub struct FactorCaseExpression { } /// -/// Type derived for production 404 +/// Type derived for production 411 /// /// `Factor: StringLiteral;` /// @@ -2586,7 +2632,7 @@ pub struct FactorStringLiteral { } /// -/// Type derived for production 405 +/// Type derived for production 412 /// /// `Factor: FactorGroup;` /// @@ -2598,7 +2644,7 @@ pub struct FactorFactorGroup { } /// -/// Type derived for production 406 +/// Type derived for production 413 /// /// `FactorGroup: Msb;` /// @@ -2610,7 +2656,7 @@ pub struct FactorGroupMsb { } /// -/// Type derived for production 407 +/// Type derived for production 414 /// /// `FactorGroup: Lsb;` /// @@ -2622,7 +2668,7 @@ pub struct FactorGroupLsb { } /// -/// Type derived for production 408 +/// Type derived for production 415 /// /// `Factor: InsideExpression;` /// @@ -2634,7 +2680,7 @@ pub struct FactorInsideExpression { } /// -/// Type derived for production 409 +/// Type derived for production 416 /// /// `Factor: OutsideExpression;` /// @@ -2646,7 +2692,7 @@ pub struct FactorOutsideExpression { } /// -/// Type derived for production 435 +/// Type derived for production 442 /// /// `ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */;` /// @@ -2659,7 +2705,7 @@ pub struct ArrayLiteralItemGroupExpressionArrayLiteralItemOpt { } /// -/// Type derived for production 436 +/// Type derived for production 443 /// /// `ArrayLiteralItemGroup: Defaul Colon Expression;` /// @@ -2673,7 +2719,7 @@ pub struct ArrayLiteralItemGroupDefaulColonExpression { } /// -/// Type derived for production 451 +/// Type derived for production 458 /// /// `TypeExpression: ScalarType;` /// @@ -2685,7 +2731,7 @@ pub struct TypeExpressionScalarType { } /// -/// Type derived for production 452 +/// Type derived for production 459 /// /// `TypeExpression: Type LParen Expression RParen;` /// @@ -2700,7 +2746,7 @@ pub struct TypeExpressionTypeLParenExpressionRParen { } /// -/// Type derived for production 464 +/// Type derived for production 471 /// /// `SelectOperator: Colon;` /// @@ -2712,7 +2758,7 @@ pub struct SelectOperatorColon { } /// -/// Type derived for production 465 +/// Type derived for production 472 /// /// `SelectOperator: PlusColon;` /// @@ -2724,7 +2770,7 @@ pub struct SelectOperatorPlusColon { } /// -/// Type derived for production 466 +/// Type derived for production 473 /// /// `SelectOperator: MinusColon;` /// @@ -2736,7 +2782,7 @@ pub struct SelectOperatorMinusColon { } /// -/// Type derived for production 467 +/// Type derived for production 474 /// /// `SelectOperator: Step;` /// @@ -2748,7 +2794,7 @@ pub struct SelectOperatorStep { } /// -/// Type derived for production 477 +/// Type derived for production 484 /// /// `RangeOperator: DotDot;` /// @@ -2760,7 +2806,7 @@ pub struct RangeOperatorDotDot { } /// -/// Type derived for production 478 +/// Type derived for production 485 /// /// `RangeOperator: DotDotEqu;` /// @@ -2772,7 +2818,7 @@ pub struct RangeOperatorDotDotEqu { } /// -/// Type derived for production 479 +/// Type derived for production 486 /// /// `FixedType: U32;` /// @@ -2784,7 +2830,7 @@ pub struct FixedTypeU32 { } /// -/// Type derived for production 480 +/// Type derived for production 487 /// /// `FixedType: U64;` /// @@ -2796,7 +2842,7 @@ pub struct FixedTypeU64 { } /// -/// Type derived for production 481 +/// Type derived for production 488 /// /// `FixedType: I32;` /// @@ -2808,7 +2854,7 @@ pub struct FixedTypeI32 { } /// -/// Type derived for production 482 +/// Type derived for production 489 /// /// `FixedType: I64;` /// @@ -2820,7 +2866,7 @@ pub struct FixedTypeI64 { } /// -/// Type derived for production 483 +/// Type derived for production 490 /// /// `FixedType: F32;` /// @@ -2832,7 +2878,7 @@ pub struct FixedTypeF32 { } /// -/// Type derived for production 484 +/// Type derived for production 491 /// /// `FixedType: F64;` /// @@ -2844,7 +2890,7 @@ pub struct FixedTypeF64 { } /// -/// Type derived for production 485 +/// Type derived for production 492 /// /// `FixedType: Strin;` /// @@ -2856,7 +2902,7 @@ pub struct FixedTypeStrin { } /// -/// Type derived for production 487 +/// Type derived for production 494 /// /// `VariableTypeGroup: Clock;` /// @@ -2868,7 +2914,7 @@ pub struct VariableTypeGroupClock { } /// -/// Type derived for production 488 +/// Type derived for production 495 /// /// `VariableTypeGroup: ClockPosedge;` /// @@ -2880,7 +2926,7 @@ pub struct VariableTypeGroupClockPosedge { } /// -/// Type derived for production 489 +/// Type derived for production 496 /// /// `VariableTypeGroup: ClockNegedge;` /// @@ -2892,7 +2938,7 @@ pub struct VariableTypeGroupClockNegedge { } /// -/// Type derived for production 490 +/// Type derived for production 497 /// /// `VariableTypeGroup: Reset;` /// @@ -2904,7 +2950,7 @@ pub struct VariableTypeGroupReset { } /// -/// Type derived for production 491 +/// Type derived for production 498 /// /// `VariableTypeGroup: ResetAsyncHigh;` /// @@ -2916,7 +2962,7 @@ pub struct VariableTypeGroupResetAsyncHigh { } /// -/// Type derived for production 492 +/// Type derived for production 499 /// /// `VariableTypeGroup: ResetAsyncLow;` /// @@ -2928,7 +2974,7 @@ pub struct VariableTypeGroupResetAsyncLow { } /// -/// Type derived for production 493 +/// Type derived for production 500 /// /// `VariableTypeGroup: ResetSyncHigh;` /// @@ -2940,7 +2986,7 @@ pub struct VariableTypeGroupResetSyncHigh { } /// -/// Type derived for production 494 +/// Type derived for production 501 /// /// `VariableTypeGroup: ResetSyncLow;` /// @@ -2952,7 +2998,7 @@ pub struct VariableTypeGroupResetSyncLow { } /// -/// Type derived for production 495 +/// Type derived for production 502 /// /// `VariableTypeGroup: Logic;` /// @@ -2964,7 +3010,7 @@ pub struct VariableTypeGroupLogic { } /// -/// Type derived for production 496 +/// Type derived for production 503 /// /// `VariableTypeGroup: Bit;` /// @@ -2976,7 +3022,7 @@ pub struct VariableTypeGroupBit { } /// -/// Type derived for production 497 +/// Type derived for production 504 /// /// `VariableTypeGroup: ScopedIdentifier;` /// @@ -2988,7 +3034,7 @@ pub struct VariableTypeGroupScopedIdentifier { } /// -/// Type derived for production 500 +/// Type derived for production 507 /// /// `TypeModifier: Tri;` /// @@ -3000,7 +3046,7 @@ pub struct TypeModifierTri { } /// -/// Type derived for production 501 +/// Type derived for production 508 /// /// `TypeModifier: Signed;` /// @@ -3012,7 +3058,7 @@ pub struct TypeModifierSigned { } /// -/// Type derived for production 503 +/// Type derived for production 510 /// /// `ScalarTypeGroup: VariableType;` /// @@ -3024,7 +3070,7 @@ pub struct ScalarTypeGroupVariableType { } /// -/// Type derived for production 504 +/// Type derived for production 511 /// /// `ScalarTypeGroup: FixedType;` /// @@ -3036,7 +3082,7 @@ pub struct ScalarTypeGroupFixedType { } /// -/// Type derived for production 510 +/// Type derived for production 517 /// /// `Statement: LetStatement;` /// @@ -3048,7 +3094,7 @@ pub struct StatementLetStatement { } /// -/// Type derived for production 511 +/// Type derived for production 518 /// /// `Statement: IdentifierStatement;` /// @@ -3060,7 +3106,7 @@ pub struct StatementIdentifierStatement { } /// -/// Type derived for production 512 +/// Type derived for production 519 /// /// `Statement: IfStatement;` /// @@ -3072,7 +3118,7 @@ pub struct StatementIfStatement { } /// -/// Type derived for production 513 +/// Type derived for production 520 /// /// `Statement: IfResetStatement;` /// @@ -3084,7 +3130,7 @@ pub struct StatementIfResetStatement { } /// -/// Type derived for production 514 +/// Type derived for production 521 /// /// `Statement: ReturnStatement;` /// @@ -3096,7 +3142,7 @@ pub struct StatementReturnStatement { } /// -/// Type derived for production 515 +/// Type derived for production 522 /// /// `Statement: BreakStatement;` /// @@ -3108,7 +3154,7 @@ pub struct StatementBreakStatement { } /// -/// Type derived for production 516 +/// Type derived for production 523 /// /// `Statement: ForStatement;` /// @@ -3120,7 +3166,7 @@ pub struct StatementForStatement { } /// -/// Type derived for production 517 +/// Type derived for production 524 /// /// `Statement: CaseStatement;` /// @@ -3132,7 +3178,7 @@ pub struct StatementCaseStatement { } /// -/// Type derived for production 520 +/// Type derived for production 527 /// /// `IdentifierStatementGroup: FunctionCall;` /// @@ -3144,7 +3190,7 @@ pub struct IdentifierStatementGroupFunctionCall { } /// -/// Type derived for production 521 +/// Type derived for production 528 /// /// `IdentifierStatementGroup: Assignment;` /// @@ -3156,7 +3202,7 @@ pub struct IdentifierStatementGroupAssignment { } /// -/// Type derived for production 523 +/// Type derived for production 530 /// /// `AssignmentGroup: Equ;` /// @@ -3168,7 +3214,7 @@ pub struct AssignmentGroupEqu { } /// -/// Type derived for production 524 +/// Type derived for production 531 /// /// `AssignmentGroup: AssignmentOperator;` /// @@ -3180,7 +3226,7 @@ pub struct AssignmentGroupAssignmentOperator { } /// -/// Type derived for production 558 +/// Type derived for production 565 /// /// `CaseItemGroup0: Statement;` /// @@ -3192,7 +3238,7 @@ pub struct CaseItemGroup0Statement { } /// -/// Type derived for production 559 +/// Type derived for production 566 /// /// `CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace;` /// @@ -3206,7 +3252,7 @@ pub struct CaseItemGroup0LBraceCaseItemGroup0ListRBrace { } /// -/// Type derived for production 562 +/// Type derived for production 569 /// /// `CaseItemGroup: Expression CaseItemGroupList /* Vec */;` /// @@ -3219,7 +3265,7 @@ pub struct CaseItemGroupExpressionCaseItemGroupList { } /// -/// Type derived for production 565 +/// Type derived for production 572 /// /// `CaseItemGroup: Defaul;` /// @@ -3231,7 +3277,7 @@ pub struct CaseItemGroupDefaul { } /// -/// Type derived for production 574 +/// Type derived for production 581 /// /// `AttributeItem: Identifier;` /// @@ -3243,7 +3289,7 @@ pub struct AttributeItemIdentifier { } /// -/// Type derived for production 575 +/// Type derived for production 582 /// /// `AttributeItem: StringLiteral;` /// @@ -3255,7 +3301,7 @@ pub struct AttributeItemStringLiteral { } /// -/// Type derived for production 579 +/// Type derived for production 586 /// /// `LocalDeclarationGroup: ArrayType Equ Expression;` /// @@ -3269,7 +3315,7 @@ pub struct LocalDeclarationGroupArrayTypeEquExpression { } /// -/// Type derived for production 580 +/// Type derived for production 587 /// /// `LocalDeclarationGroup: Type Equ TypeExpression;` /// @@ -3283,7 +3329,7 @@ pub struct LocalDeclarationGroupTypeEquTypeExpression { } /// -/// Type derived for production 600 +/// Type derived for production 607 /// /// `ModportGroupGroup: LBrace ModportList RBrace;` /// @@ -3297,7 +3343,7 @@ pub struct ModportGroupGroupLBraceModportListRBrace { } /// -/// Type derived for production 601 +/// Type derived for production 608 /// /// `ModportGroupGroup: ModportItem;` /// @@ -3309,7 +3355,7 @@ pub struct ModportGroupGroupModportItem { } /// -/// Type derived for production 612 +/// Type derived for production 619 /// /// `EnumGroupGroup: LBrace EnumList RBrace;` /// @@ -3323,7 +3369,7 @@ pub struct EnumGroupGroupLBraceEnumListRBrace { } /// -/// Type derived for production 613 +/// Type derived for production 620 /// /// `EnumGroupGroup: EnumItem;` /// @@ -3335,7 +3381,7 @@ pub struct EnumGroupGroupEnumItem { } /// -/// Type derived for production 619 +/// Type derived for production 626 /// /// `StructUnion: Struct;` /// @@ -3347,7 +3393,7 @@ pub struct StructUnionStruct { } /// -/// Type derived for production 620 +/// Type derived for production 627 /// /// `StructUnion: Union;` /// @@ -3359,7 +3405,7 @@ pub struct StructUnionUnion { } /// -/// Type derived for production 628 +/// Type derived for production 637 /// /// `StructUnionGroupGroup: LBrace StructUnionList RBrace;` /// @@ -3373,7 +3419,7 @@ pub struct StructUnionGroupGroupLBraceStructUnionListRBrace { } /// -/// Type derived for production 629 +/// Type derived for production 638 /// /// `StructUnionGroupGroup: StructUnionItem;` /// @@ -3385,7 +3431,7 @@ pub struct StructUnionGroupGroupStructUnionItem { } /// -/// Type derived for production 657 +/// Type derived for production 666 /// /// `InstParameterGroupGroup: LBrace InstParameterList RBrace;` /// @@ -3399,7 +3445,7 @@ pub struct InstParameterGroupGroupLBraceInstParameterListRBrace { } /// -/// Type derived for production 658 +/// Type derived for production 667 /// /// `InstParameterGroupGroup: InstParameterItem;` /// @@ -3411,7 +3457,7 @@ pub struct InstParameterGroupGroupInstParameterItem { } /// -/// Type derived for production 670 +/// Type derived for production 679 /// /// `InstPortGroupGroup: LBrace InstPortList RBrace;` /// @@ -3425,7 +3471,7 @@ pub struct InstPortGroupGroupLBraceInstPortListRBrace { } /// -/// Type derived for production 671 +/// Type derived for production 680 /// /// `InstPortGroupGroup: InstPortItem;` /// @@ -3437,7 +3483,7 @@ pub struct InstPortGroupGroupInstPortItem { } /// -/// Type derived for production 686 +/// Type derived for production 695 /// /// `WithParameterGroupGroup: LBrace WithParameterList RBrace;` /// @@ -3451,7 +3497,7 @@ pub struct WithParameterGroupGroupLBraceWithParameterListRBrace { } /// -/// Type derived for production 687 +/// Type derived for production 696 /// /// `WithParameterGroupGroup: WithParameterItem;` /// @@ -3463,7 +3509,7 @@ pub struct WithParameterGroupGroupWithParameterItem { } /// -/// Type derived for production 691 +/// Type derived for production 700 /// /// `WithParameterItemGroup0: ArrayType Equ Expression;` /// @@ -3477,7 +3523,7 @@ pub struct WithParameterItemGroup0ArrayTypeEquExpression { } /// -/// Type derived for production 692 +/// Type derived for production 701 /// /// `WithParameterItemGroup0: Type Equ TypeExpression;` /// @@ -3491,7 +3537,7 @@ pub struct WithParameterItemGroup0TypeEquTypeExpression { } /// -/// Type derived for production 693 +/// Type derived for production 702 /// /// `WithParameterItemGroup: Param;` /// @@ -3503,7 +3549,7 @@ pub struct WithParameterItemGroupParam { } /// -/// Type derived for production 694 +/// Type derived for production 703 /// /// `WithParameterItemGroup: Local;` /// @@ -3515,7 +3561,31 @@ pub struct WithParameterItemGroupLocal { } /// -/// Type derived for production 704 +/// Type derived for production 717 +/// +/// `WithGenericArgumentItem: ScopedIdentifier;` +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithGenericArgumentItemScopedIdentifier { + pub scoped_identifier: Box, +} + +/// +/// Type derived for production 718 +/// +/// `WithGenericArgumentItem: Number;` +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithGenericArgumentItemNumber { + pub number: Box, +} + +/// +/// Type derived for production 728 /// /// `PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace;` /// @@ -3529,7 +3599,7 @@ pub struct PortDeclarationGroupGroupLBracePortDeclarationListRBrace { } /// -/// Type derived for production 705 +/// Type derived for production 729 /// /// `PortDeclarationGroupGroup: PortDeclarationItem;` /// @@ -3541,7 +3611,7 @@ pub struct PortDeclarationGroupGroupPortDeclarationItem { } /// -/// Type derived for production 709 +/// Type derived for production 733 /// /// `PortDeclarationItemGroup: Direction ArrayType;` /// @@ -3554,7 +3624,7 @@ pub struct PortDeclarationItemGroupDirectionArrayType { } /// -/// Type derived for production 710 +/// Type derived for production 734 /// /// `PortDeclarationItemGroup: Interface PortDeclarationItemOpt /* Option */;` /// @@ -3567,7 +3637,7 @@ pub struct PortDeclarationItemGroupInterfacePortDeclarationItemOpt { } /// -/// Type derived for production 713 +/// Type derived for production 737 /// /// `Direction: Input;` /// @@ -3579,7 +3649,7 @@ pub struct DirectionInput { } /// -/// Type derived for production 714 +/// Type derived for production 738 /// /// `Direction: Output;` /// @@ -3591,7 +3661,7 @@ pub struct DirectionOutput { } /// -/// Type derived for production 715 +/// Type derived for production 739 /// /// `Direction: Inout;` /// @@ -3603,7 +3673,7 @@ pub struct DirectionInout { } /// -/// Type derived for production 716 +/// Type derived for production 740 /// /// `Direction: Ref;` /// @@ -3615,7 +3685,7 @@ pub struct DirectionRef { } /// -/// Type derived for production 717 +/// Type derived for production 741 /// /// `Direction: Modport;` /// @@ -3627,7 +3697,7 @@ pub struct DirectionModport { } /// -/// Type derived for production 725 +/// Type derived for production 751 /// /// `FunctionItem: VarDeclaration;` /// @@ -3639,7 +3709,7 @@ pub struct FunctionItemVarDeclaration { } /// -/// Type derived for production 726 +/// Type derived for production 752 /// /// `FunctionItem: Statement;` /// @@ -3651,7 +3721,7 @@ pub struct FunctionItemStatement { } /// -/// Type derived for production 731 +/// Type derived for production 757 /// /// `ExportDeclarationGroup: Star;` /// @@ -3663,7 +3733,7 @@ pub struct ExportDeclarationGroupStar { } /// -/// Type derived for production 732 +/// Type derived for production 758 /// /// `ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */;` /// @@ -3676,7 +3746,7 @@ pub struct ExportDeclarationGroupScopedIdentifierExportDeclarationOpt { } /// -/// Type derived for production 761 +/// Type derived for production 789 /// /// `ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace;` /// @@ -3690,7 +3760,7 @@ pub struct ModuleGroupGroupLBraceModuleGroupGroupListRBrace { } /// -/// Type derived for production 764 +/// Type derived for production 792 /// /// `ModuleGroupGroup: ModuleItem;` /// @@ -3702,7 +3772,7 @@ pub struct ModuleGroupGroupModuleItem { } /// -/// Type derived for production 767 +/// Type derived for production 795 /// /// `ModuleItem: LetDeclaration;` /// @@ -3714,7 +3784,7 @@ pub struct ModuleItemLetDeclaration { } /// -/// Type derived for production 768 +/// Type derived for production 796 /// /// `ModuleItem: VarDeclaration;` /// @@ -3726,7 +3796,7 @@ pub struct ModuleItemVarDeclaration { } /// -/// Type derived for production 769 +/// Type derived for production 797 /// /// `ModuleItem: InstDeclaration;` /// @@ -3738,7 +3808,7 @@ pub struct ModuleItemInstDeclaration { } /// -/// Type derived for production 770 +/// Type derived for production 798 /// /// `ModuleItem: TypeDefDeclaration;` /// @@ -3750,7 +3820,7 @@ pub struct ModuleItemTypeDefDeclaration { } /// -/// Type derived for production 771 +/// Type derived for production 799 /// /// `ModuleItem: LocalDeclaration;` /// @@ -3762,7 +3832,7 @@ pub struct ModuleItemLocalDeclaration { } /// -/// Type derived for production 772 +/// Type derived for production 800 /// /// `ModuleItem: AlwaysFfDeclaration;` /// @@ -3774,7 +3844,7 @@ pub struct ModuleItemAlwaysFfDeclaration { } /// -/// Type derived for production 773 +/// Type derived for production 801 /// /// `ModuleItem: AlwaysCombDeclaration;` /// @@ -3786,7 +3856,7 @@ pub struct ModuleItemAlwaysCombDeclaration { } /// -/// Type derived for production 774 +/// Type derived for production 802 /// /// `ModuleItem: AssignDeclaration;` /// @@ -3798,7 +3868,7 @@ pub struct ModuleItemAssignDeclaration { } /// -/// Type derived for production 775 +/// Type derived for production 803 /// /// `ModuleItem: FunctionDeclaration;` /// @@ -3810,7 +3880,7 @@ pub struct ModuleItemFunctionDeclaration { } /// -/// Type derived for production 776 +/// Type derived for production 804 /// /// `ModuleItem: ModuleIfDeclaration;` /// @@ -3822,7 +3892,7 @@ pub struct ModuleItemModuleIfDeclaration { } /// -/// Type derived for production 777 +/// Type derived for production 805 /// /// `ModuleItem: ModuleForDeclaration;` /// @@ -3834,7 +3904,7 @@ pub struct ModuleItemModuleForDeclaration { } /// -/// Type derived for production 778 +/// Type derived for production 806 /// /// `ModuleItem: EnumDeclaration;` /// @@ -3846,7 +3916,7 @@ pub struct ModuleItemEnumDeclaration { } /// -/// Type derived for production 779 +/// Type derived for production 807 /// /// `ModuleItem: StructUnionDeclaration;` /// @@ -3858,7 +3928,7 @@ pub struct ModuleItemStructUnionDeclaration { } /// -/// Type derived for production 780 +/// Type derived for production 808 /// /// `ModuleItem: ModuleNamedBlock;` /// @@ -3870,7 +3940,7 @@ pub struct ModuleItemModuleNamedBlock { } /// -/// Type derived for production 781 +/// Type derived for production 809 /// /// `ModuleItem: ImportDeclaration;` /// @@ -3882,7 +3952,7 @@ pub struct ModuleItemImportDeclaration { } /// -/// Type derived for production 782 +/// Type derived for production 810 /// /// `ModuleItem: InitialDeclaration;` /// @@ -3894,7 +3964,7 @@ pub struct ModuleItemInitialDeclaration { } /// -/// Type derived for production 783 +/// Type derived for production 811 /// /// `ModuleItem: FinalDeclaration;` /// @@ -3906,7 +3976,7 @@ pub struct ModuleItemFinalDeclaration { } /// -/// Type derived for production 808 +/// Type derived for production 838 /// /// `InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace;` /// @@ -3920,7 +3990,7 @@ pub struct InterfaceGroupGroupLBraceInterfaceGroupGroupListRBrace { } /// -/// Type derived for production 811 +/// Type derived for production 841 /// /// `InterfaceGroupGroup: InterfaceItem;` /// @@ -3932,7 +4002,7 @@ pub struct InterfaceGroupGroupInterfaceItem { } /// -/// Type derived for production 814 +/// Type derived for production 844 /// /// `InterfaceItem: LetDeclaration;` /// @@ -3944,7 +4014,7 @@ pub struct InterfaceItemLetDeclaration { } /// -/// Type derived for production 815 +/// Type derived for production 845 /// /// `InterfaceItem: VarDeclaration;` /// @@ -3956,7 +4026,7 @@ pub struct InterfaceItemVarDeclaration { } /// -/// Type derived for production 816 +/// Type derived for production 846 /// /// `InterfaceItem: LocalDeclaration;` /// @@ -3968,7 +4038,7 @@ pub struct InterfaceItemLocalDeclaration { } /// -/// Type derived for production 817 +/// Type derived for production 847 /// /// `InterfaceItem: ModportDeclaration;` /// @@ -3980,7 +4050,7 @@ pub struct InterfaceItemModportDeclaration { } /// -/// Type derived for production 818 +/// Type derived for production 848 /// /// `InterfaceItem: InterfaceIfDeclaration;` /// @@ -3992,7 +4062,7 @@ pub struct InterfaceItemInterfaceIfDeclaration { } /// -/// Type derived for production 819 +/// Type derived for production 849 /// /// `InterfaceItem: InterfaceForDeclaration;` /// @@ -4004,7 +4074,7 @@ pub struct InterfaceItemInterfaceForDeclaration { } /// -/// Type derived for production 820 +/// Type derived for production 850 /// /// `InterfaceItem: TypeDefDeclaration;` /// @@ -4016,7 +4086,7 @@ pub struct InterfaceItemTypeDefDeclaration { } /// -/// Type derived for production 821 +/// Type derived for production 851 /// /// `InterfaceItem: EnumDeclaration;` /// @@ -4028,7 +4098,7 @@ pub struct InterfaceItemEnumDeclaration { } /// -/// Type derived for production 822 +/// Type derived for production 852 /// /// `InterfaceItem: StructUnionDeclaration;` /// @@ -4040,7 +4110,7 @@ pub struct InterfaceItemStructUnionDeclaration { } /// -/// Type derived for production 823 +/// Type derived for production 853 /// /// `InterfaceItem: InterfaceNamedBlock;` /// @@ -4052,7 +4122,7 @@ pub struct InterfaceItemInterfaceNamedBlock { } /// -/// Type derived for production 824 +/// Type derived for production 854 /// /// `InterfaceItem: FunctionDeclaration;` /// @@ -4064,7 +4134,7 @@ pub struct InterfaceItemFunctionDeclaration { } /// -/// Type derived for production 825 +/// Type derived for production 855 /// /// `InterfaceItem: ImportDeclaration;` /// @@ -4076,7 +4146,7 @@ pub struct InterfaceItemImportDeclaration { } /// -/// Type derived for production 826 +/// Type derived for production 856 /// /// `InterfaceItem: InitialDeclaration;` /// @@ -4088,7 +4158,7 @@ pub struct InterfaceItemInitialDeclaration { } /// -/// Type derived for production 827 +/// Type derived for production 857 /// /// `InterfaceItem: FinalDeclaration;` /// @@ -4100,7 +4170,7 @@ pub struct InterfaceItemFinalDeclaration { } /// -/// Type derived for production 834 +/// Type derived for production 866 /// /// `PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace;` /// @@ -4114,7 +4184,7 @@ pub struct PackageGroupGroupLBracePackageGroupGroupListRBrace { } /// -/// Type derived for production 837 +/// Type derived for production 869 /// /// `PackageGroupGroup: PackageItem;` /// @@ -4126,7 +4196,7 @@ pub struct PackageGroupGroupPackageItem { } /// -/// Type derived for production 840 +/// Type derived for production 872 /// /// `PackageItem: VarDeclaration;` /// @@ -4138,7 +4208,7 @@ pub struct PackageItemVarDeclaration { } /// -/// Type derived for production 841 +/// Type derived for production 873 /// /// `PackageItem: LocalDeclaration;` /// @@ -4150,7 +4220,7 @@ pub struct PackageItemLocalDeclaration { } /// -/// Type derived for production 842 +/// Type derived for production 874 /// /// `PackageItem: TypeDefDeclaration;` /// @@ -4162,7 +4232,7 @@ pub struct PackageItemTypeDefDeclaration { } /// -/// Type derived for production 843 +/// Type derived for production 875 /// /// `PackageItem: EnumDeclaration;` /// @@ -4174,7 +4244,7 @@ pub struct PackageItemEnumDeclaration { } /// -/// Type derived for production 844 +/// Type derived for production 876 /// /// `PackageItem: StructUnionDeclaration;` /// @@ -4186,7 +4256,7 @@ pub struct PackageItemStructUnionDeclaration { } /// -/// Type derived for production 845 +/// Type derived for production 877 /// /// `PackageItem: FunctionDeclaration;` /// @@ -4198,7 +4268,7 @@ pub struct PackageItemFunctionDeclaration { } /// -/// Type derived for production 846 +/// Type derived for production 878 /// /// `PackageItem: ImportDeclaration;` /// @@ -4210,7 +4280,7 @@ pub struct PackageItemImportDeclaration { } /// -/// Type derived for production 847 +/// Type derived for production 879 /// /// `PackageItem: ExportDeclaration;` /// @@ -4222,7 +4292,7 @@ pub struct PackageItemExportDeclaration { } /// -/// Type derived for production 848 +/// Type derived for production 880 /// /// `PackageItem: InitialDeclaration;` /// @@ -4234,7 +4304,7 @@ pub struct PackageItemInitialDeclaration { } /// -/// Type derived for production 849 +/// Type derived for production 881 /// /// `PackageItem: FinalDeclaration;` /// @@ -4246,7 +4316,7 @@ pub struct PackageItemFinalDeclaration { } /// -/// Type derived for production 855 +/// Type derived for production 887 /// /// `EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm;` /// @@ -4260,7 +4330,7 @@ pub struct EmbedItemLBraceTermEmbedItemListRBraceTerm { } /// -/// Type derived for production 858 +/// Type derived for production 890 /// /// `EmbedItem: AnyTerm;` /// @@ -4272,7 +4342,7 @@ pub struct EmbedItemAnyTerm { } /// -/// Type derived for production 861 +/// Type derived for production 893 /// /// `DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace;` /// @@ -4286,7 +4356,7 @@ pub struct DescriptionGroupGroupLBraceDescriptionGroupGroupListRBrace { } /// -/// Type derived for production 864 +/// Type derived for production 896 /// /// `DescriptionGroupGroup: DescriptionItem;` /// @@ -4298,7 +4368,7 @@ pub struct DescriptionGroupGroupDescriptionItem { } /// -/// Type derived for production 867 +/// Type derived for production 899 /// /// `DescriptionItem: ModuleDeclaration;` /// @@ -4310,7 +4380,7 @@ pub struct DescriptionItemModuleDeclaration { } /// -/// Type derived for production 868 +/// Type derived for production 900 /// /// `DescriptionItem: InterfaceDeclaration;` /// @@ -4322,7 +4392,7 @@ pub struct DescriptionItemInterfaceDeclaration { } /// -/// Type derived for production 869 +/// Type derived for production 901 /// /// `DescriptionItem: PackageDeclaration;` /// @@ -4334,7 +4404,7 @@ pub struct DescriptionItemPackageDeclaration { } /// -/// Type derived for production 870 +/// Type derived for production 902 /// /// `DescriptionItem: ImportDeclaration;` /// @@ -4346,7 +4416,7 @@ pub struct DescriptionItemImportDeclaration { } /// -/// Type derived for production 871 +/// Type derived for production 903 /// /// `DescriptionItem: EmbedDeclaration;` /// @@ -4358,7 +4428,7 @@ pub struct DescriptionItemEmbedDeclaration { } /// -/// Type derived for production 872 +/// Type derived for production 904 /// /// `DescriptionItem: IncludeDeclaration;` /// @@ -5332,6 +5402,37 @@ pub struct ColonColon { pub colon_colon_token: crate::veryl_token::VerylToken, } +/// +/// Type derived for non-terminal ColonColonLAngle +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ColonColonLAngle { + pub colon_colon_l_angle_token: crate::veryl_token::VerylToken, +} + +/// +/// Type derived for non-terminal ColonColonLAngleTerm +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ColonColonLAngleTerm { + pub colon_colon_l_angle_term: crate::veryl_token::Token, /* ::< */ +} + +/// +/// Type derived for non-terminal ColonColonLAngleToken +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ColonColonLAngleToken { + pub colon_colon_l_angle_term: crate::veryl_token::Token, + pub comments: Box, +} + /// /// Type derived for non-terminal ColonColonTerm /// @@ -6777,6 +6878,7 @@ pub struct FunctionDeclaration { pub identifier: Box, pub function_declaration_opt: Option, pub function_declaration_opt0: Option, + pub function_declaration_opt1: Option, pub l_brace: Box, pub function_declaration_list: Vec, pub r_brace: Box, @@ -6799,7 +6901,7 @@ pub struct FunctionDeclarationList { #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] pub struct FunctionDeclarationOpt { - pub port_declaration: Box, + pub with_generic_parameter: Box, } /// @@ -6809,6 +6911,16 @@ pub struct FunctionDeclarationOpt { #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] pub struct FunctionDeclarationOpt0 { + pub port_declaration: Box, +} + +/// +/// Type derived for non-terminal FunctionDeclarationOpt1 +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct FunctionDeclarationOpt1 { pub minus_g_t: Box, pub scalar_type: Box, } @@ -7888,6 +8000,7 @@ pub struct InterfaceDeclaration { pub interface: Box, pub identifier: Box, pub interface_declaration_opt0: Option, + pub interface_declaration_opt1: Option, pub l_brace: Box, pub interface_declaration_list: Vec, pub r_brace: Box, @@ -7920,6 +8033,16 @@ pub struct InterfaceDeclarationOpt { #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] pub struct InterfaceDeclarationOpt0 { + pub with_generic_parameter: Box, +} + +/// +/// Type derived for non-terminal InterfaceDeclarationOpt1 +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct InterfaceDeclarationOpt1 { pub with_parameter: Box, } @@ -8639,6 +8762,7 @@ pub struct ModuleDeclaration { pub identifier: Box, pub module_declaration_opt0: Option, pub module_declaration_opt1: Option, + pub module_declaration_opt2: Option, pub l_brace: Box, pub module_declaration_list: Vec, pub r_brace: Box, @@ -8671,7 +8795,7 @@ pub struct ModuleDeclarationOpt { #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] pub struct ModuleDeclarationOpt0 { - pub with_parameter: Box, + pub with_generic_parameter: Box, } /// @@ -8681,6 +8805,16 @@ pub struct ModuleDeclarationOpt0 { #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] pub struct ModuleDeclarationOpt1 { + pub with_parameter: Box, +} + +/// +/// Type derived for non-terminal ModuleDeclarationOpt2 +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ModuleDeclarationOpt2 { pub port_declaration: Box, } @@ -9372,6 +9506,7 @@ pub struct PackageDeclaration { pub package_declaration_opt: Option, pub package: Box, pub identifier: Box, + pub package_declaration_opt0: Option, pub l_brace: Box, pub package_declaration_list: Vec, pub r_brace: Box, @@ -9397,6 +9532,16 @@ pub struct PackageDeclarationOpt { pub r#pub: Box, } +/// +/// Type derived for non-terminal PackageDeclarationOpt0 +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct PackageDeclarationOpt0 { + pub with_generic_parameter: Box, +} + /// /// Type derived for non-terminal PackageGroup /// @@ -10237,7 +10382,7 @@ pub struct ScopedIdentifier { #[derive(Debug, Clone)] pub enum ScopedIdentifierGroup { DollarIdentifier(ScopedIdentifierGroupDollarIdentifier), - Identifier(ScopedIdentifierGroupIdentifier), + IdentifierScopedIdentifierOpt(ScopedIdentifierGroupIdentifierScopedIdentifierOpt), } /// @@ -10249,6 +10394,27 @@ pub enum ScopedIdentifierGroup { pub struct ScopedIdentifierList { pub colon_colon: Box, pub identifier: Box, + pub scoped_identifier_opt0: Option, +} + +/// +/// Type derived for non-terminal ScopedIdentifierOpt +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ScopedIdentifierOpt { + pub with_generic_argument: Box, +} + +/// +/// Type derived for non-terminal ScopedIdentifierOpt0 +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct ScopedIdentifierOpt0 { + pub with_generic_argument: Box, } /// @@ -10559,11 +10725,22 @@ pub enum StructUnion { pub struct StructUnionDeclaration { pub struct_union: Box, pub identifier: Box, + pub struct_union_declaration_opt: Option, pub l_brace: Box, pub struct_union_list: Box, pub r_brace: Box, } +/// +/// Type derived for non-terminal StructUnionDeclarationOpt +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct StructUnionDeclarationOpt { + pub with_generic_parameter: Box, +} + /// /// Type derived for non-terminal StructUnionGroup /// @@ -10991,57 +11168,167 @@ pub struct WidthList { } /// -/// Type derived for non-terminal WithParameter +/// Type derived for non-terminal WithGenericArgument /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct WithParameter { - pub hash: Box, - pub l_paren: Box, - pub with_parameter_opt: Option, - pub r_paren: Box, +pub struct WithGenericArgument { + pub colon_colon_l_angle: Box, + pub with_generic_argument_list: Box, + pub r_angle: Box, } /// -/// Type derived for non-terminal WithParameterGroup +/// Type derived for non-terminal WithGenericArgumentItem /// #[allow(dead_code)] -#[derive(Builder, Debug, Clone)] -#[builder(crate = "parol_runtime::derive_builder")] -pub struct WithParameterGroup { - pub with_parameter_group_list: Vec, - pub with_parameter_group_group: Box, +#[derive(Debug, Clone)] +pub enum WithGenericArgumentItem { + ScopedIdentifier(WithGenericArgumentItemScopedIdentifier), + Number(WithGenericArgumentItemNumber), } /// -/// Type derived for non-terminal WithParameterGroupGroup +/// Type derived for non-terminal WithGenericArgumentList /// #[allow(dead_code)] -#[derive(Debug, Clone)] -pub enum WithParameterGroupGroup { - LBraceWithParameterListRBrace(WithParameterGroupGroupLBraceWithParameterListRBrace), - WithParameterItem(WithParameterGroupGroupWithParameterItem), +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithGenericArgumentList { + pub with_generic_argument_item: Box, + pub with_generic_argument_list_list: Vec, + pub with_generic_argument_list_opt: Option, } /// -/// Type derived for non-terminal WithParameterGroupList +/// Type derived for non-terminal WithGenericArgumentListList /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct WithParameterGroupList { - pub attribute: Box, +pub struct WithGenericArgumentListList { + pub comma: Box, + pub with_generic_argument_item: Box, } /// -/// Type derived for non-terminal WithParameterItem +/// Type derived for non-terminal WithGenericArgumentListOpt /// #[allow(dead_code)] #[derive(Builder, Debug, Clone)] #[builder(crate = "parol_runtime::derive_builder")] -pub struct WithParameterItem { - pub with_parameter_item_group: Box, +pub struct WithGenericArgumentListOpt { + pub comma: Box, +} + +/// +/// Type derived for non-terminal WithGenericParameter +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithGenericParameter { + pub colon_colon_l_angle: Box, + pub with_generic_parameter_list: Box, + pub r_angle: Box, +} + +/// +/// Type derived for non-terminal WithGenericParameterItem +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithGenericParameterItem { + pub identifier: Box, +} + +/// +/// Type derived for non-terminal WithGenericParameterList +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithGenericParameterList { + pub with_generic_parameter_item: Box, + pub with_generic_parameter_list_list: Vec, + pub with_generic_parameter_list_opt: Option, +} + +/// +/// Type derived for non-terminal WithGenericParameterListList +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithGenericParameterListList { + pub comma: Box, + pub with_generic_parameter_item: Box, +} + +/// +/// Type derived for non-terminal WithGenericParameterListOpt +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithGenericParameterListOpt { + pub comma: Box, +} + +/// +/// Type derived for non-terminal WithParameter +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithParameter { + pub hash: Box, + pub l_paren: Box, + pub with_parameter_opt: Option, + pub r_paren: Box, +} + +/// +/// Type derived for non-terminal WithParameterGroup +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithParameterGroup { + pub with_parameter_group_list: Vec, + pub with_parameter_group_group: Box, +} + +/// +/// Type derived for non-terminal WithParameterGroupGroup +/// +#[allow(dead_code)] +#[derive(Debug, Clone)] +pub enum WithParameterGroupGroup { + LBraceWithParameterListRBrace(WithParameterGroupGroupLBraceWithParameterListRBrace), + WithParameterItem(WithParameterGroupGroupWithParameterItem), +} + +/// +/// Type derived for non-terminal WithParameterGroupList +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithParameterGroupList { + pub attribute: Box, +} + +/// +/// Type derived for non-terminal WithParameterItem +/// +#[allow(dead_code)] +#[derive(Builder, Debug, Clone)] +#[builder(crate = "parol_runtime::derive_builder")] +pub struct WithParameterItem { + pub with_parameter_item_group: Box, pub identifier: Box, pub colon: Box, pub with_parameter_item_group0: Box, @@ -11206,6 +11493,9 @@ pub enum ASTType { ClockToken(ClockToken), Colon(Colon), ColonColon(ColonColon), + ColonColonLAngle(ColonColonLAngle), + ColonColonLAngleTerm(ColonColonLAngleTerm), + ColonColonLAngleToken(ColonColonLAngleToken), ColonColonTerm(ColonColonTerm), ColonColonToken(ColonColonToken), ColonTerm(ColonTerm), @@ -11341,6 +11631,7 @@ pub enum ASTType { FunctionDeclarationList(Vec), FunctionDeclarationOpt(Option), FunctionDeclarationOpt0(Option), + FunctionDeclarationOpt1(Option), FunctionItem(FunctionItem), FunctionTerm(FunctionTerm), FunctionToken(FunctionToken), @@ -11441,6 +11732,7 @@ pub enum ASTType { InterfaceDeclarationList(Vec), InterfaceDeclarationOpt(Option), InterfaceDeclarationOpt0(Option), + InterfaceDeclarationOpt1(Option), InterfaceForDeclaration(InterfaceForDeclaration), InterfaceForDeclarationOpt(Option), InterfaceGroup(InterfaceGroup), @@ -11509,6 +11801,7 @@ pub enum ASTType { ModuleDeclarationOpt(Option), ModuleDeclarationOpt0(Option), ModuleDeclarationOpt1(Option), + ModuleDeclarationOpt2(Option), ModuleForDeclaration(ModuleForDeclaration), ModuleForDeclarationOpt(Option), ModuleGroup(ModuleGroup), @@ -11574,6 +11867,7 @@ pub enum ASTType { PackageDeclaration(PackageDeclaration), PackageDeclarationList(Vec), PackageDeclarationOpt(Option), + PackageDeclarationOpt0(Option), PackageGroup(PackageGroup), PackageGroupGroup(PackageGroupGroup), PackageGroupGroupList(Vec), @@ -11655,6 +11949,8 @@ pub enum ASTType { ScopedIdentifier(ScopedIdentifier), ScopedIdentifierGroup(ScopedIdentifierGroup), ScopedIdentifierList(Vec), + ScopedIdentifierOpt(Option), + ScopedIdentifierOpt0(Option), Select(Select), SelectOperator(SelectOperator), SelectOpt(Option), @@ -11684,6 +11980,7 @@ pub enum ASTType { StructToken(StructToken), StructUnion(StructUnion), StructUnionDeclaration(StructUnionDeclaration), + StructUnionDeclarationOpt(Option), StructUnionGroup(StructUnionGroup), StructUnionGroupGroup(StructUnionGroupGroup), StructUnionGroupList(Vec), @@ -11723,6 +12020,16 @@ pub enum ASTType { VerylList(Vec), Width(Width), WidthList(Vec), + WithGenericArgument(WithGenericArgument), + WithGenericArgumentItem(WithGenericArgumentItem), + WithGenericArgumentList(WithGenericArgumentList), + WithGenericArgumentListList(Vec), + WithGenericArgumentListOpt(Option), + WithGenericParameter(WithGenericParameter), + WithGenericParameterItem(WithGenericParameterItem), + WithGenericParameterList(WithGenericParameterList), + WithGenericParameterListList(Vec), + WithGenericParameterListOpt(Option), WithParameter(WithParameter), WithParameterGroup(WithParameterGroup), WithParameterGroupGroup(WithParameterGroupGroup), @@ -11800,7 +12107,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { /// Semantic action for production 0: /// - /// `CommentsTerm: "(?:(?:(?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))\s*)+" : Token;` + /// `CommentsTerm: "(?:(?:(?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))\s*)+" : Token;` /// #[parol_runtime::function_name::named] fn comments_term(&mut self, comments_term: &ParseTreeType<'t>) -> Result<()> { @@ -11819,7 +12126,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { /// Semantic action for production 1: /// - /// `StringLiteralTerm: "\u{0022}(?:\\[\u{0022}\\/bfnrt]|u[0-9a-fA-F]{4}|[^\u{0022}\\\u0000-\u001F])*\u{0022}" : Token;` + /// `StringLiteralTerm: "\u{0022}(?:\\[\u{0022}\\/bfnrt]|u[0-9a-fA-F]{4}|[^\u{0022}\\\u0000-\u001F])*\u{0022}" : Token;` /// #[parol_runtime::function_name::named] fn string_literal_term(&mut self, string_literal_term: &ParseTreeType<'t>) -> Result<()> { @@ -11844,7 +12151,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { /// Semantic action for production 2: /// - /// `ExponentTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*[eE][+-]?[0-9]+(?:_[0-9]+)*/ : Token;` + /// `ExponentTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*[eE][+-]?[0-9]+(?:_[0-9]+)*/ : Token;` /// #[parol_runtime::function_name::named] fn exponent_term(&mut self, exponent_term: &ParseTreeType<'t>) -> Result<()> { @@ -11863,7 +12170,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { /// Semantic action for production 3: /// - /// `FixedPointTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*/ : Token;` + /// `FixedPointTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*/ : Token;` /// #[parol_runtime::function_name::named] fn fixed_point_term(&mut self, fixed_point_term: &ParseTreeType<'t>) -> Result<()> { @@ -11883,7 +12190,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { /// Semantic action for production 4: /// - /// `BasedTerm: /(?:[0-9]+(?:_[0-9]+)*)?'[bodh][0-9a-fA-FxzXZ]+(?:_[0-9a-fA-FxzXZ]+)*/ : Token;` + /// `BasedTerm: /(?:[0-9]+(?:_[0-9]+)*)?'[bodh][0-9a-fA-FxzXZ]+(?:_[0-9a-fA-FxzXZ]+)*/ : Token;` /// #[parol_runtime::function_name::named] fn based_term(&mut self, based_term: &ParseTreeType<'t>) -> Result<()> { @@ -11902,7 +12209,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { /// Semantic action for production 5: /// - /// `AllBitTerm: /(?:[0-9]+(?:_[0-9]+)*)?'[01xzXZ]/ : Token;` + /// `AllBitTerm: /(?:[0-9]+(?:_[0-9]+)*)?'[01xzXZ]/ : Token;` /// #[parol_runtime::function_name::named] fn all_bit_term(&mut self, all_bit_term: &ParseTreeType<'t>) -> Result<()> { @@ -11921,7 +12228,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { /// Semantic action for production 6: /// - /// `BaseLessTerm: /[0-9]+(?:_[0-9]+)*/ : Token;` + /// `BaseLessTerm: /[0-9]+(?:_[0-9]+)*/ : Token;` /// #[parol_runtime::function_name::named] fn base_less_term(&mut self, base_less_term: &ParseTreeType<'t>) -> Result<()> { @@ -12260,7 +12567,35 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { /// Semantic action for production 23: /// - /// `ColonColonTerm: '::' : Token;` + /// `ColonColonLAngleTerm: '::<' : Token;` + /// + #[parol_runtime::function_name::named] + fn colon_colon_l_angle_term( + &mut self, + colon_colon_l_angle_term: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let colon_colon_l_angle_term = colon_colon_l_angle_term + .token()? + .try_into() + .map_err(parol_runtime::ParolError::UserError)?; + let colon_colon_l_angle_term_built = ColonColonLAngleTerm { + colon_colon_l_angle_term, + }; + // Calling user action here + self.user_grammar + .colon_colon_l_angle_term(&colon_colon_l_angle_term_built)?; + self.push( + ASTType::ColonColonLAngleTerm(colon_colon_l_angle_term_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 24: + /// + /// `ColonColonTerm: '::' : Token;` /// #[parol_runtime::function_name::named] fn colon_colon_term(&mut self, colon_colon_term: &ParseTreeType<'t>) -> Result<()> { @@ -12278,9 +12613,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 24: + /// Semantic action for production 25: /// - /// `ColonTerm: ':' : Token;` + /// `ColonTerm: ':' : Token;` /// #[parol_runtime::function_name::named] fn colon_term(&mut self, colon_term: &ParseTreeType<'t>) -> Result<()> { @@ -12297,9 +12632,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 25: + /// Semantic action for production 26: /// - /// `CommaTerm: ',' : Token;` + /// `CommaTerm: ',' : Token;` /// #[parol_runtime::function_name::named] fn comma_term(&mut self, comma_term: &ParseTreeType<'t>) -> Result<()> { @@ -12316,9 +12651,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 26: + /// Semantic action for production 27: /// - /// `DotDotEquTerm: '..=' : Token;` + /// `DotDotEquTerm: '..=' : Token;` /// #[parol_runtime::function_name::named] fn dot_dot_equ_term(&mut self, dot_dot_equ_term: &ParseTreeType<'t>) -> Result<()> { @@ -12336,9 +12671,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 27: + /// Semantic action for production 28: /// - /// `DotDotTerm: '..' : Token;` + /// `DotDotTerm: '..' : Token;` /// #[parol_runtime::function_name::named] fn dot_dot_term(&mut self, dot_dot_term: &ParseTreeType<'t>) -> Result<()> { @@ -12355,9 +12690,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 28: + /// Semantic action for production 29: /// - /// `DotTerm: '.' : Token;` + /// `DotTerm: '.' : Token;` /// #[parol_runtime::function_name::named] fn dot_term(&mut self, dot_term: &ParseTreeType<'t>) -> Result<()> { @@ -12374,9 +12709,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 29: + /// Semantic action for production 30: /// - /// `EquTerm: '=' : Token;` + /// `EquTerm: '=' : Token;` /// #[parol_runtime::function_name::named] fn equ_term(&mut self, equ_term: &ParseTreeType<'t>) -> Result<()> { @@ -12393,9 +12728,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 30: + /// Semantic action for production 31: /// - /// `HashTerm: '#' : Token;` + /// `HashTerm: '#' : Token;` /// #[parol_runtime::function_name::named] fn hash_term(&mut self, hash_term: &ParseTreeType<'t>) -> Result<()> { @@ -12412,9 +12747,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 31: + /// Semantic action for production 32: /// - /// `LAngleTerm: '<' : Token;` + /// `LAngleTerm: '<' : Token;` /// #[parol_runtime::function_name::named] fn l_angle_term(&mut self, l_angle_term: &ParseTreeType<'t>) -> Result<()> { @@ -12431,9 +12766,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 32: + /// Semantic action for production 33: /// - /// `QuoteLBraceTerm: "'\{" : Token;` + /// `QuoteLBraceTerm: "'\{" : Token;` /// #[parol_runtime::function_name::named] fn quote_l_brace_term(&mut self, quote_l_brace_term: &ParseTreeType<'t>) -> Result<()> { @@ -12451,9 +12786,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 33: + /// Semantic action for production 34: /// - /// `LBraceTerm: '{' : Token;` + /// `LBraceTerm: '{' : Token;` /// #[parol_runtime::function_name::named] fn l_brace_term(&mut self, l_brace_term: &ParseTreeType<'t>) -> Result<()> { @@ -12470,9 +12805,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 34: + /// Semantic action for production 35: /// - /// `LBracketTerm: '[' : Token;` + /// `LBracketTerm: '[' : Token;` /// #[parol_runtime::function_name::named] fn l_bracket_term(&mut self, l_bracket_term: &ParseTreeType<'t>) -> Result<()> { @@ -12489,9 +12824,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 35: + /// Semantic action for production 36: /// - /// `LParenTerm: '(' : Token;` + /// `LParenTerm: '(' : Token;` /// #[parol_runtime::function_name::named] fn l_paren_term(&mut self, l_paren_term: &ParseTreeType<'t>) -> Result<()> { @@ -12508,9 +12843,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 36: + /// Semantic action for production 37: /// - /// `RAngleTerm: '>' : Token;` + /// `RAngleTerm: '>' : Token;` /// #[parol_runtime::function_name::named] fn r_angle_term(&mut self, r_angle_term: &ParseTreeType<'t>) -> Result<()> { @@ -12527,9 +12862,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 37: + /// Semantic action for production 38: /// - /// `RBraceTerm: '}' : Token;` + /// `RBraceTerm: '}' : Token;` /// #[parol_runtime::function_name::named] fn r_brace_term(&mut self, r_brace_term: &ParseTreeType<'t>) -> Result<()> { @@ -12546,9 +12881,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 38: + /// Semantic action for production 39: /// - /// `RBracketTerm: ']' : Token;` + /// `RBracketTerm: ']' : Token;` /// #[parol_runtime::function_name::named] fn r_bracket_term(&mut self, r_bracket_term: &ParseTreeType<'t>) -> Result<()> { @@ -12565,9 +12900,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 39: + /// Semantic action for production 40: /// - /// `RParenTerm: ')' : Token;` + /// `RParenTerm: ')' : Token;` /// #[parol_runtime::function_name::named] fn r_paren_term(&mut self, r_paren_term: &ParseTreeType<'t>) -> Result<()> { @@ -12584,9 +12919,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 40: + /// Semantic action for production 41: /// - /// `SemicolonTerm: ';' : Token;` + /// `SemicolonTerm: ';' : Token;` /// #[parol_runtime::function_name::named] fn semicolon_term(&mut self, semicolon_term: &ParseTreeType<'t>) -> Result<()> { @@ -12603,9 +12938,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 41: + /// Semantic action for production 42: /// - /// `StarTerm: '*' : Token;` + /// `StarTerm: '*' : Token;` /// #[parol_runtime::function_name::named] fn star_term(&mut self, star_term: &ParseTreeType<'t>) -> Result<()> { @@ -12622,9 +12957,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 42: + /// Semantic action for production 43: /// - /// `AlwaysCombTerm: /(?-u:\b)always_comb(?-u:\b)/ : Token;` + /// `AlwaysCombTerm: /(?-u:\b)always_comb(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn always_comb_term(&mut self, always_comb_term: &ParseTreeType<'t>) -> Result<()> { @@ -12642,9 +12977,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 43: + /// Semantic action for production 44: /// - /// `AlwaysFfTerm: /(?-u:\b)always_ff(?-u:\b)/ : Token;` + /// `AlwaysFfTerm: /(?-u:\b)always_ff(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn always_ff_term(&mut self, always_ff_term: &ParseTreeType<'t>) -> Result<()> { @@ -12661,9 +12996,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 44: + /// Semantic action for production 45: /// - /// `AssignTerm: /(?-u:\b)assign(?-u:\b)/ : Token;` + /// `AssignTerm: /(?-u:\b)assign(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn assign_term(&mut self, assign_term: &ParseTreeType<'t>) -> Result<()> { @@ -12680,9 +13015,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 45: + /// Semantic action for production 46: /// - /// `AsTerm: /(?-u:\b)as(?-u:\b)/ : Token;` + /// `AsTerm: /(?-u:\b)as(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn as_term(&mut self, as_term: &ParseTreeType<'t>) -> Result<()> { @@ -12699,9 +13034,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 46: + /// Semantic action for production 47: /// - /// `BitTerm: /(?-u:\b)bit(?-u:\b)/ : Token;` + /// `BitTerm: /(?-u:\b)bit(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn bit_term(&mut self, bit_term: &ParseTreeType<'t>) -> Result<()> { @@ -12718,9 +13053,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 47: + /// Semantic action for production 48: /// - /// `CaseTerm: /(?-u:\b)case(?-u:\b)/ : Token;` + /// `CaseTerm: /(?-u:\b)case(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn case_term(&mut self, case_term: &ParseTreeType<'t>) -> Result<()> { @@ -12737,9 +13072,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 48: + /// Semantic action for production 49: /// - /// `ClockTerm: /(?-u:\b)clock(?-u:\b)/ : Token;` + /// `ClockTerm: /(?-u:\b)clock(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn clock_term(&mut self, clock_term: &ParseTreeType<'t>) -> Result<()> { @@ -12756,9 +13091,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 49: + /// Semantic action for production 50: /// - /// `ClockPosedgeTerm: /(?-u:\b)clock_posedge(?-u:\b)/ : Token;` + /// `ClockPosedgeTerm: /(?-u:\b)clock_posedge(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn clock_posedge_term(&mut self, clock_posedge_term: &ParseTreeType<'t>) -> Result<()> { @@ -12776,9 +13111,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 50: + /// Semantic action for production 51: /// - /// `ClockNegedgeTerm: /(?-u:\b)clock_negedge(?-u:\b)/ : Token;` + /// `ClockNegedgeTerm: /(?-u:\b)clock_negedge(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn clock_negedge_term(&mut self, clock_negedge_term: &ParseTreeType<'t>) -> Result<()> { @@ -12796,9 +13131,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 51: + /// Semantic action for production 52: /// - /// `DefaultTerm: /(?-u:\b)default(?-u:\b)/ : Token;` + /// `DefaultTerm: /(?-u:\b)default(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn default_term(&mut self, default_term: &ParseTreeType<'t>) -> Result<()> { @@ -12815,9 +13150,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 52: + /// Semantic action for production 53: /// - /// `ElseTerm: /(?-u:\b)else(?-u:\b)/ : Token;` + /// `ElseTerm: /(?-u:\b)else(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn else_term(&mut self, else_term: &ParseTreeType<'t>) -> Result<()> { @@ -12834,9 +13169,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 53: + /// Semantic action for production 54: /// - /// `EmbedTerm: /(?-u:\b)embed(?-u:\b)/ : Token;` + /// `EmbedTerm: /(?-u:\b)embed(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn embed_term(&mut self, embed_term: &ParseTreeType<'t>) -> Result<()> { @@ -12853,9 +13188,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 54: + /// Semantic action for production 55: /// - /// `EnumTerm: /(?-u:\b)enum(?-u:\b)/ : Token;` + /// `EnumTerm: /(?-u:\b)enum(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn enum_term(&mut self, enum_term: &ParseTreeType<'t>) -> Result<()> { @@ -12872,9 +13207,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 55: + /// Semantic action for production 56: /// - /// `ExportTerm: /(?-u:\b)export(?-u:\b)/ : Token;` + /// `ExportTerm: /(?-u:\b)export(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn export_term(&mut self, export_term: &ParseTreeType<'t>) -> Result<()> { @@ -12891,9 +13226,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 56: + /// Semantic action for production 57: /// - /// `F32Term: /(?-u:\b)f32(?-u:\b)/ : Token;` + /// `F32Term: /(?-u:\b)f32(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn f32_term(&mut self, f32_term: &ParseTreeType<'t>) -> Result<()> { @@ -12910,9 +13245,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 57: + /// Semantic action for production 58: /// - /// `F64Term: /(?-u:\b)f64(?-u:\b)/ : Token;` + /// `F64Term: /(?-u:\b)f64(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn f64_term(&mut self, f64_term: &ParseTreeType<'t>) -> Result<()> { @@ -12929,9 +13264,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 58: + /// Semantic action for production 59: /// - /// `FinalTerm: /(?-u:\b)final(?-u:\b)/ : Token;` + /// `FinalTerm: /(?-u:\b)final(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn final_term(&mut self, final_term: &ParseTreeType<'t>) -> Result<()> { @@ -12948,9 +13283,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 59: + /// Semantic action for production 60: /// - /// `ForTerm: /(?-u:\b)for(?-u:\b)/ : Token;` + /// `ForTerm: /(?-u:\b)for(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn for_term(&mut self, for_term: &ParseTreeType<'t>) -> Result<()> { @@ -12967,9 +13302,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 60: + /// Semantic action for production 61: /// - /// `FunctionTerm: /(?-u:\b)function(?-u:\b)/ : Token;` + /// `FunctionTerm: /(?-u:\b)function(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn function_term(&mut self, function_term: &ParseTreeType<'t>) -> Result<()> { @@ -12986,9 +13321,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 61: + /// Semantic action for production 62: /// - /// `I32Term: /(?-u:\b)i32(?-u:\b)/ : Token;` + /// `I32Term: /(?-u:\b)i32(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn i32_term(&mut self, i32_term: &ParseTreeType<'t>) -> Result<()> { @@ -13005,9 +13340,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 62: + /// Semantic action for production 63: /// - /// `I64Term: /(?-u:\b)i64(?-u:\b)/ : Token;` + /// `I64Term: /(?-u:\b)i64(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn i64_term(&mut self, i64_term: &ParseTreeType<'t>) -> Result<()> { @@ -13024,9 +13359,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 63: + /// Semantic action for production 64: /// - /// `IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/ : Token;` + /// `IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn if_reset_term(&mut self, if_reset_term: &ParseTreeType<'t>) -> Result<()> { @@ -13043,9 +13378,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 64: + /// Semantic action for production 65: /// - /// `IfTerm: /(?-u:\b)if(?-u:\b)/ : Token;` + /// `IfTerm: /(?-u:\b)if(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn if_term(&mut self, if_term: &ParseTreeType<'t>) -> Result<()> { @@ -13062,9 +13397,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 65: + /// Semantic action for production 66: /// - /// `ImportTerm: /(?-u:\b)import(?-u:\b)/ : Token;` + /// `ImportTerm: /(?-u:\b)import(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn import_term(&mut self, import_term: &ParseTreeType<'t>) -> Result<()> { @@ -13081,9 +13416,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 66: + /// Semantic action for production 67: /// - /// `IncludeTerm: /(?-u:\b)include(?-u:\b)/ : Token;` + /// `IncludeTerm: /(?-u:\b)include(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn include_term(&mut self, include_term: &ParseTreeType<'t>) -> Result<()> { @@ -13100,9 +13435,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 67: + /// Semantic action for production 68: /// - /// `InitialTerm: /(?-u:\b)initial(?-u:\b)/ : Token;` + /// `InitialTerm: /(?-u:\b)initial(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn initial_term(&mut self, initial_term: &ParseTreeType<'t>) -> Result<()> { @@ -13119,9 +13454,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 68: + /// Semantic action for production 69: /// - /// `InoutTerm: /(?-u:\b)inout(?-u:\b)/ : Token;` + /// `InoutTerm: /(?-u:\b)inout(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn inout_term(&mut self, inout_term: &ParseTreeType<'t>) -> Result<()> { @@ -13138,9 +13473,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 69: + /// Semantic action for production 70: /// - /// `InputTerm: /(?-u:\b)input(?-u:\b)/ : Token;` + /// `InputTerm: /(?-u:\b)input(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn input_term(&mut self, input_term: &ParseTreeType<'t>) -> Result<()> { @@ -13157,9 +13492,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 70: + /// Semantic action for production 71: /// - /// `InsideTerm: /(?-u:\b)inside(?-u:\b)/ : Token;` + /// `InsideTerm: /(?-u:\b)inside(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn inside_term(&mut self, inside_term: &ParseTreeType<'t>) -> Result<()> { @@ -13176,9 +13511,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 71: + /// Semantic action for production 72: /// - /// `InstTerm: /(?-u:\b)inst(?-u:\b)/ : Token;` + /// `InstTerm: /(?-u:\b)inst(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn inst_term(&mut self, inst_term: &ParseTreeType<'t>) -> Result<()> { @@ -13195,9 +13530,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 72: + /// Semantic action for production 73: /// - /// `InterfaceTerm: /(?-u:\b)interface(?-u:\b)/ : Token;` + /// `InterfaceTerm: /(?-u:\b)interface(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn interface_term(&mut self, interface_term: &ParseTreeType<'t>) -> Result<()> { @@ -13214,9 +13549,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 73: + /// Semantic action for production 74: /// - /// `InTerm: /(?-u:\b)in(?-u:\b)/ : Token;` + /// `InTerm: /(?-u:\b)in(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn in_term(&mut self, in_term: &ParseTreeType<'t>) -> Result<()> { @@ -13233,9 +13568,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 74: + /// Semantic action for production 75: /// - /// `LetTerm: /(?-u:\b)let(?-u:\b)/ : Token;` + /// `LetTerm: /(?-u:\b)let(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn let_term(&mut self, let_term: &ParseTreeType<'t>) -> Result<()> { @@ -13252,9 +13587,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 75: + /// Semantic action for production 76: /// - /// `LocalTerm: /(?-u:\b)local(?-u:\b)/ : Token;` + /// `LocalTerm: /(?-u:\b)local(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn local_term(&mut self, local_term: &ParseTreeType<'t>) -> Result<()> { @@ -13271,9 +13606,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 76: + /// Semantic action for production 77: /// - /// `LogicTerm: /(?-u:\b)logic(?-u:\b)/ : Token;` + /// `LogicTerm: /(?-u:\b)logic(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn logic_term(&mut self, logic_term: &ParseTreeType<'t>) -> Result<()> { @@ -13290,9 +13625,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 77: + /// Semantic action for production 78: /// - /// `LsbTerm: /(?-u:\b)lsb(?-u:\b)/ : Token;` + /// `LsbTerm: /(?-u:\b)lsb(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn lsb_term(&mut self, lsb_term: &ParseTreeType<'t>) -> Result<()> { @@ -13309,9 +13644,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 78: + /// Semantic action for production 79: /// - /// `ModportTerm: /(?-u:\b)modport(?-u:\b)/ : Token;` + /// `ModportTerm: /(?-u:\b)modport(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn modport_term(&mut self, modport_term: &ParseTreeType<'t>) -> Result<()> { @@ -13328,9 +13663,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 79: + /// Semantic action for production 80: /// - /// `ModuleTerm: /(?-u:\b)module(?-u:\b)/ : Token;` + /// `ModuleTerm: /(?-u:\b)module(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn module_term(&mut self, module_term: &ParseTreeType<'t>) -> Result<()> { @@ -13347,9 +13682,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 80: + /// Semantic action for production 81: /// - /// `MsbTerm: /(?-u:\b)msb(?-u:\b)/ : Token;` + /// `MsbTerm: /(?-u:\b)msb(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn msb_term(&mut self, msb_term: &ParseTreeType<'t>) -> Result<()> { @@ -13366,9 +13701,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 81: + /// Semantic action for production 82: /// - /// `OutputTerm: /(?-u:\b)output(?-u:\b)/ : Token;` + /// `OutputTerm: /(?-u:\b)output(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn output_term(&mut self, output_term: &ParseTreeType<'t>) -> Result<()> { @@ -13385,9 +13720,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 82: + /// Semantic action for production 83: /// - /// `OutsideTerm: /(?-u:\b)outside(?-u:\b)/ : Token;` + /// `OutsideTerm: /(?-u:\b)outside(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn outside_term(&mut self, outside_term: &ParseTreeType<'t>) -> Result<()> { @@ -13404,9 +13739,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 83: + /// Semantic action for production 84: /// - /// `PackageTerm: /(?-u:\b)package(?-u:\b)/ : Token;` + /// `PackageTerm: /(?-u:\b)package(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn package_term(&mut self, package_term: &ParseTreeType<'t>) -> Result<()> { @@ -13423,9 +13758,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 84: + /// Semantic action for production 85: /// - /// `ParamTerm: /(?-u:\b)param(?-u:\b)/ : Token;` + /// `ParamTerm: /(?-u:\b)param(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn param_term(&mut self, param_term: &ParseTreeType<'t>) -> Result<()> { @@ -13442,9 +13777,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 85: + /// Semantic action for production 86: /// - /// `PubTerm: /(?-u:\b)pub(?-u:\b)/ : Token;` + /// `PubTerm: /(?-u:\b)pub(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn pub_term(&mut self, pub_term: &ParseTreeType<'t>) -> Result<()> { @@ -13461,9 +13796,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 86: + /// Semantic action for production 87: /// - /// `RefTerm: /(?-u:\b)ref(?-u:\b)/ : Token;` + /// `RefTerm: /(?-u:\b)ref(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn ref_term(&mut self, ref_term: &ParseTreeType<'t>) -> Result<()> { @@ -13480,9 +13815,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 87: + /// Semantic action for production 88: /// - /// `RepeatTerm: /(?-u:\b)repeat(?-u:\b)/ : Token;` + /// `RepeatTerm: /(?-u:\b)repeat(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn repeat_term(&mut self, repeat_term: &ParseTreeType<'t>) -> Result<()> { @@ -13499,9 +13834,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 88: + /// Semantic action for production 89: /// - /// `ResetTerm: /(?-u:\b)reset(?-u:\b)/ : Token;` + /// `ResetTerm: /(?-u:\b)reset(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn reset_term(&mut self, reset_term: &ParseTreeType<'t>) -> Result<()> { @@ -13518,9 +13853,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 89: + /// Semantic action for production 90: /// - /// `ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/ : Token;` + /// `ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn reset_async_high_term(&mut self, reset_async_high_term: &ParseTreeType<'t>) -> Result<()> { @@ -13543,9 +13878,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 90: + /// Semantic action for production 91: /// - /// `ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/ : Token;` + /// `ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn reset_async_low_term(&mut self, reset_async_low_term: &ParseTreeType<'t>) -> Result<()> { @@ -13568,9 +13903,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 91: + /// Semantic action for production 92: /// - /// `ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/ : Token;` + /// `ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn reset_sync_high_term(&mut self, reset_sync_high_term: &ParseTreeType<'t>) -> Result<()> { @@ -13593,9 +13928,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 92: + /// Semantic action for production 93: /// - /// `ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/ : Token;` + /// `ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn reset_sync_low_term(&mut self, reset_sync_low_term: &ParseTreeType<'t>) -> Result<()> { @@ -13618,9 +13953,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 93: + /// Semantic action for production 94: /// - /// `ReturnTerm: /(?-u:\b)return(?-u:\b)/ : Token;` + /// `ReturnTerm: /(?-u:\b)return(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn return_term(&mut self, return_term: &ParseTreeType<'t>) -> Result<()> { @@ -13637,9 +13972,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 94: + /// Semantic action for production 95: /// - /// `BreakTerm: /(?-u:\b)break(?-u:\b)/ : Token;` + /// `BreakTerm: /(?-u:\b)break(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn break_term(&mut self, break_term: &ParseTreeType<'t>) -> Result<()> { @@ -13656,9 +13991,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 95: + /// Semantic action for production 96: /// - /// `SignedTerm: /(?-u:\b)signed(?-u:\b)/ : Token;` + /// `SignedTerm: /(?-u:\b)signed(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn signed_term(&mut self, signed_term: &ParseTreeType<'t>) -> Result<()> { @@ -13675,9 +14010,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 96: + /// Semantic action for production 97: /// - /// `StepTerm: /(?-u:\b)step(?-u:\b)/ : Token;` + /// `StepTerm: /(?-u:\b)step(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn step_term(&mut self, step_term: &ParseTreeType<'t>) -> Result<()> { @@ -13694,9 +14029,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 97: + /// Semantic action for production 98: /// - /// `StringTerm: /(?-u:\b)string(?-u:\b)/ : Token;` + /// `StringTerm: /(?-u:\b)string(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn string_term(&mut self, string_term: &ParseTreeType<'t>) -> Result<()> { @@ -13713,9 +14048,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 98: + /// Semantic action for production 99: /// - /// `StructTerm: /(?-u:\b)struct(?-u:\b)/ : Token;` + /// `StructTerm: /(?-u:\b)struct(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn struct_term(&mut self, struct_term: &ParseTreeType<'t>) -> Result<()> { @@ -13732,9 +14067,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 99: + /// Semantic action for production 100: /// - /// `TriTerm: /(?-u:\b)tri(?-u:\b)/ : Token;` + /// `TriTerm: /(?-u:\b)tri(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn tri_term(&mut self, tri_term: &ParseTreeType<'t>) -> Result<()> { @@ -13751,9 +14086,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 100: + /// Semantic action for production 101: /// - /// `TypeTerm: /(?-u:\b)type(?-u:\b)/ : Token;` + /// `TypeTerm: /(?-u:\b)type(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn type_term(&mut self, type_term: &ParseTreeType<'t>) -> Result<()> { @@ -13770,9 +14105,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 101: + /// Semantic action for production 102: /// - /// `U32Term: /(?-u:\b)u32(?-u:\b)/ : Token;` + /// `U32Term: /(?-u:\b)u32(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn u32_term(&mut self, u32_term: &ParseTreeType<'t>) -> Result<()> { @@ -13789,9 +14124,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 102: + /// Semantic action for production 103: /// - /// `U64Term: /(?-u:\b)u64(?-u:\b)/ : Token;` + /// `U64Term: /(?-u:\b)u64(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn u64_term(&mut self, u64_term: &ParseTreeType<'t>) -> Result<()> { @@ -13808,9 +14143,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 103: + /// Semantic action for production 104: /// - /// `UnionTerm: /(?-u:\b)union(?-u:\b)/ : Token;` + /// `UnionTerm: /(?-u:\b)union(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn union_term(&mut self, union_term: &ParseTreeType<'t>) -> Result<()> { @@ -13827,9 +14162,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 104: + /// Semantic action for production 105: /// - /// `VarTerm: /(?-u:\b)var(?-u:\b)/ : Token;` + /// `VarTerm: /(?-u:\b)var(?-u:\b)/ : Token;` /// #[parol_runtime::function_name::named] fn var_term(&mut self, var_term: &ParseTreeType<'t>) -> Result<()> { @@ -13846,9 +14181,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 105: + /// Semantic action for production 106: /// - /// `DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/ : Token;` + /// `DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/ : Token;` /// #[parol_runtime::function_name::named] fn dollar_identifier_term(&mut self, dollar_identifier_term: &ParseTreeType<'t>) -> Result<()> { @@ -13871,9 +14206,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 106: + /// Semantic action for production 107: /// - /// `IdentifierTerm: /[a-zA-Z_][0-9a-zA-Z_$]*/ : Token;` + /// `IdentifierTerm: /[a-zA-Z_][0-9a-zA-Z_$]*/ : Token;` /// #[parol_runtime::function_name::named] fn identifier_term(&mut self, identifier_term: &ParseTreeType<'t>) -> Result<()> { @@ -13890,7 +14225,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 107: + /// Semantic action for production 108: /// /// `AnyTerm: /[^{}]*/ : Token;` /// @@ -13909,7 +14244,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 108: + /// Semantic action for production 109: /// /// `Comments: CommentsOpt /* Option */;` /// @@ -13925,7 +14260,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 109: + /// Semantic action for production 110: /// /// `CommentsOpt /* Option::Some */: CommentsTerm;` /// @@ -13941,7 +14276,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 110: + /// Semantic action for production 111: /// /// `CommentsOpt /* Option::None */: ;` /// @@ -13953,7 +14288,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 111: + /// Semantic action for production 112: /// /// `StartToken: Comments;` /// @@ -13971,7 +14306,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 112: + /// Semantic action for production 113: /// /// `StringLiteralToken: StringLiteralTerm : Token Comments;` /// @@ -14001,7 +14336,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 113: + /// Semantic action for production 114: /// /// `ExponentToken: ExponentTerm : Token Comments;` /// @@ -14027,7 +14362,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 114: + /// Semantic action for production 115: /// /// `FixedPointToken: FixedPointTerm : Token Comments;` /// @@ -14054,7 +14389,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 115: + /// Semantic action for production 116: /// /// `BasedToken: BasedTerm : Token Comments;` /// @@ -14080,7 +14415,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 116: + /// Semantic action for production 117: /// /// `BaseLessToken: BaseLessTerm : Token Comments;` /// @@ -14106,7 +14441,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 117: + /// Semantic action for production 118: /// /// `AllBitToken: AllBitTerm : Token Comments;` /// @@ -14132,7 +14467,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 118: + /// Semantic action for production 119: /// /// `AssignmentOperatorToken: AssignmentOperatorTerm : Token Comments;` /// @@ -14167,7 +14502,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 119: + /// Semantic action for production 120: /// /// `Operator01Token: Operator01Term : Token Comments;` /// @@ -14194,7 +14529,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 120: + /// Semantic action for production 121: /// /// `Operator02Token: Operator02Term : Token Comments;` /// @@ -14221,7 +14556,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 121: + /// Semantic action for production 122: /// /// `Operator03Token: Operator03Term : Token Comments;` /// @@ -14248,7 +14583,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 122: + /// Semantic action for production 123: /// /// `Operator04Token: Operator04Term : Token Comments;` /// @@ -14275,7 +14610,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 123: + /// Semantic action for production 124: /// /// `Operator05Token: Operator05Term : Token Comments;` /// @@ -14302,7 +14637,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 124: + /// Semantic action for production 125: /// /// `Operator06Token: Operator06Term : Token Comments;` /// @@ -14329,7 +14664,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 125: + /// Semantic action for production 126: /// /// `Operator07Token: Operator07Term : Token Comments;` /// @@ -14356,7 +14691,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 126: + /// Semantic action for production 127: /// /// `Operator08Token: Operator08Term : Token Comments;` /// @@ -14383,7 +14718,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 127: + /// Semantic action for production 128: /// /// `Operator09Token: Operator09Term : Token Comments;` /// @@ -14410,7 +14745,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 128: + /// Semantic action for production 129: /// /// `Operator10Token: Operator10Term : Token Comments;` /// @@ -14437,7 +14772,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 129: + /// Semantic action for production 130: /// /// `Operator11Token: Operator11Term : Token Comments;` /// @@ -14464,7 +14799,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 130: + /// Semantic action for production 131: /// /// `UnaryOperatorToken: UnaryOperatorTerm : Token Comments;` /// @@ -14494,7 +14829,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 131: + /// Semantic action for production 132: /// /// `ColonToken: ColonTerm : Token Comments;` /// @@ -14520,7 +14855,42 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 132: + /// Semantic action for production 133: + /// + /// `ColonColonLAngleToken: ColonColonLAngleTerm : Token Comments;` + /// + #[parol_runtime::function_name::named] + fn colon_colon_l_angle_token( + &mut self, + _colon_colon_l_angle_term: &ParseTreeType<'t>, + _comments: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let comments = pop_item!(self, comments, Comments, context); + let colon_colon_l_angle_term = pop_item!( + self, + colon_colon_l_angle_term, + ColonColonLAngleTerm, + context + ); + let colon_colon_l_angle_token_built = ColonColonLAngleToken { + colon_colon_l_angle_term: (&colon_colon_l_angle_term) + .try_into() + .map_err(parol_runtime::ParolError::UserError)?, + comments: Box::new(comments), + }; + // Calling user action here + self.user_grammar + .colon_colon_l_angle_token(&colon_colon_l_angle_token_built)?; + self.push( + ASTType::ColonColonLAngleToken(colon_colon_l_angle_token_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 134: /// /// `ColonColonToken: ColonColonTerm : Token Comments;` /// @@ -14547,7 +14917,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 133: + /// Semantic action for production 135: /// /// `CommaToken: CommaTerm : Token Comments;` /// @@ -14573,7 +14943,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 134: + /// Semantic action for production 136: /// /// `DotDotToken: DotDotTerm : Token Comments;` /// @@ -14599,7 +14969,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 135: + /// Semantic action for production 137: /// /// `DotDotEquToken: DotDotEquTerm : Token Comments;` /// @@ -14626,7 +14996,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 136: + /// Semantic action for production 138: /// /// `DotToken: DotTerm : Token Comments;` /// @@ -14652,7 +15022,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 137: + /// Semantic action for production 139: /// /// `EquToken: EquTerm : Token Comments;` /// @@ -14678,7 +15048,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 138: + /// Semantic action for production 140: /// /// `HashToken: HashTerm : Token Comments;` /// @@ -14704,7 +15074,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 139: + /// Semantic action for production 141: /// /// `QuoteLBraceToken: QuoteLBraceTerm : Token Comments;` /// @@ -14734,7 +15104,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 140: + /// Semantic action for production 142: /// /// `LAngleToken: LAngleTerm : Token Comments;` /// @@ -14760,7 +15130,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 141: + /// Semantic action for production 143: /// /// `LBraceToken: LBraceTerm : Token Comments;` /// @@ -14786,7 +15156,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 142: + /// Semantic action for production 144: /// /// `LBracketToken: LBracketTerm : Token Comments;` /// @@ -14812,7 +15182,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 143: + /// Semantic action for production 145: /// /// `LParenToken: LParenTerm : Token Comments;` /// @@ -14838,7 +15208,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 144: + /// Semantic action for production 146: /// /// `MinusColonToken: MinusColonTerm : Token Comments;` /// @@ -14865,7 +15235,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 145: + /// Semantic action for production 147: /// /// `MinusGTToken: MinusGTTerm : Token Comments;` /// @@ -14891,7 +15261,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 146: + /// Semantic action for production 148: /// /// `PlusColonToken: PlusColonTerm : Token Comments;` /// @@ -14918,7 +15288,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 147: + /// Semantic action for production 149: /// /// `RAngleToken: RAngleTerm : Token Comments;` /// @@ -14944,7 +15314,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 148: + /// Semantic action for production 150: /// /// `RBraceToken: RBraceTerm : Token Comments;` /// @@ -14970,7 +15340,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 149: + /// Semantic action for production 151: /// /// `RBracketToken: RBracketTerm : Token Comments;` /// @@ -14996,7 +15366,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 150: + /// Semantic action for production 152: /// /// `RParenToken: RParenTerm : Token Comments;` /// @@ -15022,7 +15392,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 151: + /// Semantic action for production 153: /// /// `SemicolonToken: SemicolonTerm : Token Comments;` /// @@ -15048,7 +15418,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 152: + /// Semantic action for production 154: /// /// `StarToken: StarTerm : Token Comments;` /// @@ -15074,7 +15444,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 153: + /// Semantic action for production 155: /// /// `AlwaysCombToken: AlwaysCombTerm : Token Comments;` /// @@ -15101,7 +15471,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 154: + /// Semantic action for production 156: /// /// `AlwaysFfToken: AlwaysFfTerm : Token Comments;` /// @@ -15127,7 +15497,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 155: + /// Semantic action for production 157: /// /// `AsToken: AsTerm : Token Comments;` /// @@ -15153,7 +15523,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 156: + /// Semantic action for production 158: /// /// `AssignToken: AssignTerm : Token Comments;` /// @@ -15179,7 +15549,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 157: + /// Semantic action for production 159: /// /// `BitToken: BitTerm : Token Comments;` /// @@ -15205,7 +15575,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 158: + /// Semantic action for production 160: /// /// `CaseToken: CaseTerm : Token Comments;` /// @@ -15231,7 +15601,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 159: + /// Semantic action for production 161: /// /// `ClockToken: ClockTerm : Token Comments;` /// @@ -15257,7 +15627,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 160: + /// Semantic action for production 162: /// /// `ClockPosedgeToken: ClockPosedgeTerm : Token Comments;` /// @@ -15287,7 +15657,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 161: + /// Semantic action for production 163: /// /// `ClockNegedgeToken: ClockNegedgeTerm : Token Comments;` /// @@ -15317,7 +15687,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 162: + /// Semantic action for production 164: /// /// `DefaultToken: DefaultTerm : Token Comments;` /// @@ -15343,7 +15713,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 163: + /// Semantic action for production 165: /// /// `ElseToken: ElseTerm : Token Comments;` /// @@ -15369,7 +15739,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 164: + /// Semantic action for production 166: /// /// `EmbedToken: EmbedTerm : Token Comments;` /// @@ -15395,7 +15765,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 165: + /// Semantic action for production 167: /// /// `EnumToken: EnumTerm : Token Comments;` /// @@ -15421,7 +15791,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 166: + /// Semantic action for production 168: /// /// `ExportToken: ExportTerm : Token Comments;` /// @@ -15447,7 +15817,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 167: + /// Semantic action for production 169: /// /// `F32Token: F32Term : Token Comments;` /// @@ -15473,7 +15843,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 168: + /// Semantic action for production 170: /// /// `F64Token: F64Term : Token Comments;` /// @@ -15499,7 +15869,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 169: + /// Semantic action for production 171: /// /// `FinalToken: FinalTerm : Token Comments;` /// @@ -15525,7 +15895,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 170: + /// Semantic action for production 172: /// /// `ForToken: ForTerm : Token Comments;` /// @@ -15551,7 +15921,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 171: + /// Semantic action for production 173: /// /// `FunctionToken: FunctionTerm : Token Comments;` /// @@ -15577,7 +15947,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 172: + /// Semantic action for production 174: /// /// `I32Token: I32Term : Token Comments;` /// @@ -15603,7 +15973,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 173: + /// Semantic action for production 175: /// /// `I64Token: I64Term : Token Comments;` /// @@ -15629,7 +15999,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 174: + /// Semantic action for production 176: /// /// `IfResetToken: IfResetTerm : Token Comments;` /// @@ -15655,7 +16025,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 175: + /// Semantic action for production 177: /// /// `IfToken: IfTerm : Token Comments;` /// @@ -15681,7 +16051,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 176: + /// Semantic action for production 178: /// /// `ImportToken: ImportTerm : Token Comments;` /// @@ -15707,7 +16077,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 177: + /// Semantic action for production 179: /// /// `IncludeToken: IncludeTerm : Token Comments;` /// @@ -15733,7 +16103,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 178: + /// Semantic action for production 180: /// /// `InitialToken: InitialTerm : Token Comments;` /// @@ -15759,7 +16129,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 179: + /// Semantic action for production 181: /// /// `InoutToken: InoutTerm : Token Comments;` /// @@ -15785,7 +16155,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 180: + /// Semantic action for production 182: /// /// `InputToken: InputTerm : Token Comments;` /// @@ -15811,7 +16181,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 181: + /// Semantic action for production 183: /// /// `InsideToken: InsideTerm : Token Comments;` /// @@ -15837,7 +16207,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 182: + /// Semantic action for production 184: /// /// `InstToken: InstTerm : Token Comments;` /// @@ -15863,7 +16233,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 183: + /// Semantic action for production 185: /// /// `InterfaceToken: InterfaceTerm : Token Comments;` /// @@ -15889,7 +16259,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 184: + /// Semantic action for production 186: /// /// `InToken: InTerm : Token Comments;` /// @@ -15915,7 +16285,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 185: + /// Semantic action for production 187: /// /// `LetToken: LetTerm : Token Comments;` /// @@ -15941,7 +16311,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 186: + /// Semantic action for production 188: /// /// `LocalToken: LocalTerm : Token Comments;` /// @@ -15967,7 +16337,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 187: + /// Semantic action for production 189: /// /// `LogicToken: LogicTerm : Token Comments;` /// @@ -15993,7 +16363,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 188: + /// Semantic action for production 190: /// /// `LsbToken: LsbTerm : Token Comments;` /// @@ -16019,7 +16389,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 189: + /// Semantic action for production 191: /// /// `ModportToken: ModportTerm : Token Comments;` /// @@ -16045,7 +16415,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 190: + /// Semantic action for production 192: /// /// `ModuleToken: ModuleTerm : Token Comments;` /// @@ -16071,7 +16441,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 191: + /// Semantic action for production 193: /// /// `MsbToken: MsbTerm : Token Comments;` /// @@ -16097,7 +16467,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 192: + /// Semantic action for production 194: /// /// `OutputToken: OutputTerm : Token Comments;` /// @@ -16123,7 +16493,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 193: + /// Semantic action for production 195: /// /// `OutsideToken: OutsideTerm : Token Comments;` /// @@ -16149,7 +16519,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 194: + /// Semantic action for production 196: /// /// `PackageToken: PackageTerm : Token Comments;` /// @@ -16175,7 +16545,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 195: + /// Semantic action for production 197: /// /// `ParamToken: ParamTerm : Token Comments;` /// @@ -16201,7 +16571,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 196: + /// Semantic action for production 198: /// /// `PubToken: PubTerm : Token Comments;` /// @@ -16227,7 +16597,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 197: + /// Semantic action for production 199: /// /// `RefToken: RefTerm : Token Comments;` /// @@ -16253,7 +16623,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 198: + /// Semantic action for production 200: /// /// `RepeatToken: RepeatTerm : Token Comments;` /// @@ -16279,7 +16649,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 199: + /// Semantic action for production 201: /// /// `ResetToken: ResetTerm : Token Comments;` /// @@ -16305,7 +16675,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 200: + /// Semantic action for production 202: /// /// `ResetAsyncHighToken: ResetAsyncHighTerm : Token Comments;` /// @@ -16336,7 +16706,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 201: + /// Semantic action for production 203: /// /// `ResetAsyncLowToken: ResetAsyncLowTerm : Token Comments;` /// @@ -16367,7 +16737,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 202: + /// Semantic action for production 204: /// /// `ResetSyncHighToken: ResetSyncHighTerm : Token Comments;` /// @@ -16398,7 +16768,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 203: + /// Semantic action for production 205: /// /// `ResetSyncLowToken: ResetSyncLowTerm : Token Comments;` /// @@ -16428,7 +16798,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 204: + /// Semantic action for production 206: /// /// `ReturnToken: ReturnTerm : Token Comments;` /// @@ -16454,7 +16824,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 205: + /// Semantic action for production 207: /// /// `BreakToken: BreakTerm : Token Comments;` /// @@ -16480,7 +16850,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 206: + /// Semantic action for production 208: /// /// `SignedToken: SignedTerm : Token Comments;` /// @@ -16506,7 +16876,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 207: + /// Semantic action for production 209: /// /// `StepToken: StepTerm : Token Comments;` /// @@ -16532,7 +16902,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 208: + /// Semantic action for production 210: /// /// `StringToken: StringTerm : Token Comments;` /// @@ -16558,7 +16928,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 209: + /// Semantic action for production 211: /// /// `StructToken: StructTerm : Token Comments;` /// @@ -16584,7 +16954,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 210: + /// Semantic action for production 212: /// /// `TriToken: TriTerm : Token Comments;` /// @@ -16610,7 +16980,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 211: + /// Semantic action for production 213: /// /// `TypeToken: TypeTerm : Token Comments;` /// @@ -16636,7 +17006,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 212: + /// Semantic action for production 214: /// /// `U32Token: U32Term : Token Comments;` /// @@ -16662,7 +17032,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 213: + /// Semantic action for production 215: /// /// `U64Token: U64Term : Token Comments;` /// @@ -16688,7 +17058,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 214: + /// Semantic action for production 216: /// /// `UnionToken: UnionTerm : Token Comments;` /// @@ -16714,7 +17084,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 215: + /// Semantic action for production 217: /// /// `VarToken: VarTerm : Token Comments;` /// @@ -16740,7 +17110,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 216: + /// Semantic action for production 218: /// /// `DollarIdentifierToken: DollarIdentifierTerm : Token Comments;` /// @@ -16771,7 +17141,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 217: + /// Semantic action for production 219: /// /// `IdentifierToken: IdentifierTerm : Token Comments;` /// @@ -16798,7 +17168,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 218: + /// Semantic action for production 220: /// /// `Start: StartToken : VerylToken;` /// @@ -16818,7 +17188,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 219: + /// Semantic action for production 221: /// /// `StringLiteral: StringLiteralToken : VerylToken;` /// @@ -16839,7 +17209,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 220: + /// Semantic action for production 222: /// /// `Exponent: ExponentToken : VerylToken;` /// @@ -16859,7 +17229,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 221: + /// Semantic action for production 223: /// /// `FixedPoint: FixedPointToken : VerylToken;` /// @@ -16879,7 +17249,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 222: + /// Semantic action for production 224: /// /// `Based: BasedToken : VerylToken;` /// @@ -16899,7 +17269,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 223: + /// Semantic action for production 225: /// /// `BaseLess: BaseLessToken : VerylToken;` /// @@ -16919,7 +17289,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 224: + /// Semantic action for production 226: /// /// `AllBit: AllBitToken : VerylToken;` /// @@ -16939,7 +17309,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 225: + /// Semantic action for production 227: /// /// `AssignmentOperator: AssignmentOperatorToken : VerylToken;` /// @@ -16971,7 +17341,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 226: + /// Semantic action for production 228: /// /// `Operator01: Operator01Token : VerylToken;` /// @@ -16991,7 +17361,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 227: + /// Semantic action for production 229: /// /// `Operator02: Operator02Token : VerylToken;` /// @@ -17011,7 +17381,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 228: + /// Semantic action for production 230: /// /// `Operator03: Operator03Token : VerylToken;` /// @@ -17031,7 +17401,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 229: + /// Semantic action for production 231: /// /// `Operator04: Operator04Token : VerylToken;` /// @@ -17051,7 +17421,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 230: + /// Semantic action for production 232: /// /// `Operator05: Operator05Token : VerylToken;` /// @@ -17071,7 +17441,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 231: + /// Semantic action for production 233: /// /// `Operator06: Operator06Token : VerylToken;` /// @@ -17091,7 +17461,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 232: + /// Semantic action for production 234: /// /// `Operator07: Operator07Token : VerylToken;` /// @@ -17111,7 +17481,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 233: + /// Semantic action for production 235: /// /// `Operator08: Operator08Token : VerylToken;` /// @@ -17131,7 +17501,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 234: + /// Semantic action for production 236: /// /// `Operator09: Operator09Token : VerylToken;` /// @@ -17151,7 +17521,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 235: + /// Semantic action for production 237: /// /// `Operator10: Operator10Token : VerylToken;` /// @@ -17171,7 +17541,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 236: + /// Semantic action for production 238: /// /// `Operator11: Operator11Token : VerylToken;` /// @@ -17191,7 +17561,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 237: + /// Semantic action for production 239: /// /// `UnaryOperator: UnaryOperatorToken : VerylToken;` /// @@ -17212,7 +17582,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 238: + /// Semantic action for production 240: /// /// `Colon: ColonToken : VerylToken;` /// @@ -17232,7 +17602,39 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 239: + /// Semantic action for production 241: + /// + /// `ColonColonLAngle: ColonColonLAngleToken : VerylToken;` + /// + #[parol_runtime::function_name::named] + fn colon_colon_l_angle( + &mut self, + _colon_colon_l_angle_token: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let colon_colon_l_angle_token = pop_item!( + self, + colon_colon_l_angle_token, + ColonColonLAngleToken, + context + ); + let colon_colon_l_angle_built = ColonColonLAngle { + colon_colon_l_angle_token: (&colon_colon_l_angle_token) + .try_into() + .map_err(parol_runtime::ParolError::UserError)?, + }; + // Calling user action here + self.user_grammar + .colon_colon_l_angle(&colon_colon_l_angle_built)?; + self.push( + ASTType::ColonColonLAngle(colon_colon_l_angle_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 242: /// /// `ColonColon: ColonColonToken : VerylToken;` /// @@ -17252,7 +17654,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 240: + /// Semantic action for production 243: /// /// `Comma: CommaToken : VerylToken;` /// @@ -17272,7 +17674,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 241: + /// Semantic action for production 244: /// /// `DotDot: DotDotToken : VerylToken;` /// @@ -17292,7 +17694,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 242: + /// Semantic action for production 245: /// /// `DotDotEqu: DotDotEquToken : VerylToken;` /// @@ -17312,7 +17714,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 243: + /// Semantic action for production 246: /// /// `Dot: DotToken : VerylToken;` /// @@ -17332,7 +17734,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 244: + /// Semantic action for production 247: /// /// `Equ: EquToken : VerylToken;` /// @@ -17352,7 +17754,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 245: + /// Semantic action for production 248: /// /// `Hash: HashToken : VerylToken;` /// @@ -17372,7 +17774,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 246: + /// Semantic action for production 249: /// /// `QuoteLBrace: QuoteLBraceToken : VerylToken;` /// @@ -17392,7 +17794,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 247: + /// Semantic action for production 250: /// /// `LAngle: LAngleToken : VerylToken;` /// @@ -17412,7 +17814,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 248: + /// Semantic action for production 251: /// /// `LBrace: LBraceToken : VerylToken;` /// @@ -17432,7 +17834,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 249: + /// Semantic action for production 252: /// /// `LBracket: LBracketToken : VerylToken;` /// @@ -17452,7 +17854,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 250: + /// Semantic action for production 253: /// /// `LParen: LParenToken : VerylToken;` /// @@ -17472,7 +17874,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 251: + /// Semantic action for production 254: /// /// `MinusColon: MinusColonToken : VerylToken;` /// @@ -17492,7 +17894,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 252: + /// Semantic action for production 255: /// /// `MinusGT: MinusGTToken : VerylToken;` /// @@ -17512,7 +17914,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 253: + /// Semantic action for production 256: /// /// `PlusColon: PlusColonToken : VerylToken;` /// @@ -17532,7 +17934,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 254: + /// Semantic action for production 257: /// /// `RAngle: RAngleToken : VerylToken;` /// @@ -17552,7 +17954,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 255: + /// Semantic action for production 258: /// /// `RBrace: RBraceToken : VerylToken;` /// @@ -17572,7 +17974,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 256: + /// Semantic action for production 259: /// /// `RBracket: RBracketToken : VerylToken;` /// @@ -17592,7 +17994,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 257: + /// Semantic action for production 260: /// /// `RParen: RParenToken : VerylToken;` /// @@ -17612,7 +18014,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 258: + /// Semantic action for production 261: /// /// `Semicolon: SemicolonToken : VerylToken;` /// @@ -17632,7 +18034,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 259: + /// Semantic action for production 262: /// /// `Star: StarToken : VerylToken;` /// @@ -17652,7 +18054,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 260: + /// Semantic action for production 263: /// /// `AlwaysComb: AlwaysCombToken : VerylToken;` /// @@ -17672,7 +18074,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 261: + /// Semantic action for production 264: /// /// `AlwaysFf: AlwaysFfToken : VerylToken;` /// @@ -17692,7 +18094,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 262: + /// Semantic action for production 265: /// /// `As: AsToken : VerylToken;` /// @@ -17712,7 +18114,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 263: + /// Semantic action for production 266: /// /// `Assign: AssignToken : VerylToken;` /// @@ -17732,7 +18134,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 264: + /// Semantic action for production 267: /// /// `Bit: BitToken : VerylToken;` /// @@ -17752,7 +18154,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 265: + /// Semantic action for production 268: /// /// `Break: BreakToken : VerylToken;` /// @@ -17772,7 +18174,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 266: + /// Semantic action for production 269: /// /// `Case: CaseToken : VerylToken;` /// @@ -17792,7 +18194,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 267: + /// Semantic action for production 270: /// /// `Clock: ClockToken : VerylToken;` /// @@ -17812,7 +18214,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 268: + /// Semantic action for production 271: /// /// `ClockPosedge: ClockPosedgeToken : VerylToken;` /// @@ -17832,7 +18234,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 269: + /// Semantic action for production 272: /// /// `ClockNegedge: ClockNegedgeToken : VerylToken;` /// @@ -17852,7 +18254,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 270: + /// Semantic action for production 273: /// /// `Defaul: DefaultToken : VerylToken;` /// @@ -17872,7 +18274,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 271: + /// Semantic action for production 274: /// /// `Else: ElseToken : VerylToken;` /// @@ -17892,7 +18294,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 272: + /// Semantic action for production 275: /// /// `Embed: EmbedToken : VerylToken;` /// @@ -17912,7 +18314,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 273: + /// Semantic action for production 276: /// /// `Enum: EnumToken : VerylToken;` /// @@ -17932,7 +18334,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 274: + /// Semantic action for production 277: /// /// `Export: ExportToken : VerylToken;` /// @@ -17952,7 +18354,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 275: + /// Semantic action for production 278: /// /// `F32: F32Token : VerylToken;` /// @@ -17972,7 +18374,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 276: + /// Semantic action for production 279: /// /// `F64: F64Token : VerylToken;` /// @@ -17992,7 +18394,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 277: + /// Semantic action for production 280: /// /// `Final: FinalToken : VerylToken;` /// @@ -18012,7 +18414,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 278: + /// Semantic action for production 281: /// /// `For: ForToken : VerylToken;` /// @@ -18032,7 +18434,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 279: + /// Semantic action for production 282: /// /// `Function: FunctionToken : VerylToken;` /// @@ -18052,7 +18454,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 280: + /// Semantic action for production 283: /// /// `I32: I32Token : VerylToken;` /// @@ -18072,7 +18474,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 281: + /// Semantic action for production 284: /// /// `I64: I64Token : VerylToken;` /// @@ -18092,7 +18494,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 282: + /// Semantic action for production 285: /// /// `If: IfToken : VerylToken;` /// @@ -18112,7 +18514,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 283: + /// Semantic action for production 286: /// /// `IfReset: IfResetToken : VerylToken;` /// @@ -18132,7 +18534,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 284: + /// Semantic action for production 287: /// /// `Import: ImportToken : VerylToken;` /// @@ -18152,7 +18554,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 285: + /// Semantic action for production 288: /// /// `In: InToken : VerylToken;` /// @@ -18172,7 +18574,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 286: + /// Semantic action for production 289: /// /// `Include: IncludeToken : VerylToken;` /// @@ -18192,7 +18594,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 287: + /// Semantic action for production 290: /// /// `Initial: InitialToken : VerylToken;` /// @@ -18212,7 +18614,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 288: + /// Semantic action for production 291: /// /// `Inout: InoutToken : VerylToken;` /// @@ -18232,7 +18634,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 289: + /// Semantic action for production 292: /// /// `Input: InputToken : VerylToken;` /// @@ -18252,7 +18654,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 290: + /// Semantic action for production 293: /// /// `Inside: InsideToken : VerylToken;` /// @@ -18272,7 +18674,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 291: + /// Semantic action for production 294: /// /// `Inst: InstToken : VerylToken;` /// @@ -18292,7 +18694,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 292: + /// Semantic action for production 295: /// /// `Interface: InterfaceToken : VerylToken;` /// @@ -18312,7 +18714,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 293: + /// Semantic action for production 296: /// /// `Let: LetToken : VerylToken;` /// @@ -18332,7 +18734,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 294: + /// Semantic action for production 297: /// /// `Local: LocalToken : VerylToken;` /// @@ -18352,7 +18754,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 295: + /// Semantic action for production 298: /// /// `Logic: LogicToken : VerylToken;` /// @@ -18372,7 +18774,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 296: + /// Semantic action for production 299: /// /// `Lsb: LsbToken : VerylToken;` /// @@ -18392,7 +18794,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 297: + /// Semantic action for production 300: /// /// `Modport: ModportToken : VerylToken;` /// @@ -18412,7 +18814,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 298: + /// Semantic action for production 301: /// /// `Module: ModuleToken : VerylToken;` /// @@ -18432,7 +18834,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 299: + /// Semantic action for production 302: /// /// `Msb: MsbToken : VerylToken;` /// @@ -18452,7 +18854,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 300: + /// Semantic action for production 303: /// /// `Output: OutputToken : VerylToken;` /// @@ -18472,7 +18874,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 301: + /// Semantic action for production 304: /// /// `Outside: OutsideToken : VerylToken;` /// @@ -18492,7 +18894,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 302: + /// Semantic action for production 305: /// /// `Package: PackageToken : VerylToken;` /// @@ -18512,7 +18914,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 303: + /// Semantic action for production 306: /// /// `Param: ParamToken : VerylToken;` /// @@ -18532,7 +18934,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 304: + /// Semantic action for production 307: /// /// `Pub: PubToken : VerylToken;` /// @@ -18552,7 +18954,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 305: + /// Semantic action for production 308: /// /// `Ref: RefToken : VerylToken;` /// @@ -18572,7 +18974,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 306: + /// Semantic action for production 309: /// /// `Repeat: RepeatToken : VerylToken;` /// @@ -18592,7 +18994,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 307: + /// Semantic action for production 310: /// /// `Reset: ResetToken : VerylToken;` /// @@ -18612,7 +19014,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 308: + /// Semantic action for production 311: /// /// `ResetAsyncHigh: ResetAsyncHighToken : VerylToken;` /// @@ -18634,7 +19036,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 309: + /// Semantic action for production 312: /// /// `ResetAsyncLow: ResetAsyncLowToken : VerylToken;` /// @@ -18655,7 +19057,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 310: + /// Semantic action for production 313: /// /// `ResetSyncHigh: ResetSyncHighToken : VerylToken;` /// @@ -18676,7 +19078,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 311: + /// Semantic action for production 314: /// /// `ResetSyncLow: ResetSyncLowToken : VerylToken;` /// @@ -18697,7 +19099,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 312: + /// Semantic action for production 315: /// /// `Return: ReturnToken : VerylToken;` /// @@ -18717,7 +19119,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 313: + /// Semantic action for production 316: /// /// `Signed: SignedToken : VerylToken;` /// @@ -18737,7 +19139,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 314: + /// Semantic action for production 317: /// /// `Step: StepToken : VerylToken;` /// @@ -18757,7 +19159,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 315: + /// Semantic action for production 318: /// /// `Strin: StringToken : VerylToken;` /// @@ -18777,7 +19179,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 316: + /// Semantic action for production 319: /// /// `Struct: StructToken : VerylToken;` /// @@ -18797,7 +19199,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 317: + /// Semantic action for production 320: /// /// `Tri: TriToken : VerylToken;` /// @@ -18817,7 +19219,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 318: + /// Semantic action for production 321: /// /// `Type: TypeToken : VerylToken;` /// @@ -18837,7 +19239,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 319: + /// Semantic action for production 322: /// /// `U32: U32Token : VerylToken;` /// @@ -18857,7 +19259,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 320: + /// Semantic action for production 323: /// /// `U64: U64Token : VerylToken;` /// @@ -18877,7 +19279,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 321: + /// Semantic action for production 324: /// /// `Union: UnionToken : VerylToken;` /// @@ -18897,7 +19299,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 322: + /// Semantic action for production 325: /// /// `Var: VarToken : VerylToken;` /// @@ -18917,7 +19319,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 323: + /// Semantic action for production 326: /// /// `DollarIdentifier: DollarIdentifierToken : VerylToken;` /// @@ -18943,7 +19345,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 324: + /// Semantic action for production 327: /// /// `Identifier: IdentifierToken : VerylToken;` /// @@ -18963,7 +19365,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 325: + /// Semantic action for production 328: /// /// `Number: IntegralNumber;` /// @@ -18982,7 +19384,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 326: + /// Semantic action for production 329: /// /// `Number: RealNumber;` /// @@ -19001,7 +19403,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 327: + /// Semantic action for production 330: /// /// `IntegralNumber: Based;` /// @@ -19021,7 +19423,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 328: + /// Semantic action for production 331: /// /// `IntegralNumber: BaseLess;` /// @@ -19041,7 +19443,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 329: + /// Semantic action for production 332: /// /// `IntegralNumber: AllBit;` /// @@ -19061,7 +19463,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 330: + /// Semantic action for production 333: /// /// `RealNumber: FixedPoint;` /// @@ -19080,7 +19482,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 331: + /// Semantic action for production 334: /// /// `RealNumber: Exponent;` /// @@ -19099,7 +19501,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 332: + /// Semantic action for production 335: /// /// `HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */;` /// @@ -19140,7 +19542,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 333: + /// Semantic action for production 336: /// /// `HierarchicalIdentifierList0 /* Vec::Push */: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0;` /// @@ -19182,7 +19584,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 334: + /// Semantic action for production 337: /// /// `HierarchicalIdentifierList0List /* Vec::Push */: Select HierarchicalIdentifierList0List;` /// @@ -19213,7 +19615,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 335: + /// Semantic action for production 338: /// /// `HierarchicalIdentifierList0List /* Vec::New */: ;` /// @@ -19229,7 +19631,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 336: + /// Semantic action for production 339: /// /// `HierarchicalIdentifierList0 /* Vec::New */: ;` /// @@ -19245,7 +19647,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 337: + /// Semantic action for production 340: /// /// `HierarchicalIdentifierList /* Vec::Push */: Select HierarchicalIdentifierList;` /// @@ -19276,7 +19678,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 338: + /// Semantic action for production 341: /// /// `HierarchicalIdentifierList /* Vec::New */: ;` /// @@ -19292,7 +19694,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 339: + /// Semantic action for production 342: /// /// `ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */;` /// @@ -19323,7 +19725,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 340: + /// Semantic action for production 343: /// /// `ScopedIdentifierGroup: DollarIdentifier;` /// @@ -19344,20 +19746,27 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 341: + /// Semantic action for production 344: /// - /// `ScopedIdentifierGroup: Identifier;` + /// `ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */;` /// #[parol_runtime::function_name::named] - fn scoped_identifier_group_1(&mut self, _identifier: &ParseTreeType<'t>) -> Result<()> { + fn scoped_identifier_group_1( + &mut self, + _identifier: &ParseTreeType<'t>, + _scoped_identifier_opt: &ParseTreeType<'t>, + ) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); + let scoped_identifier_opt = + pop_item!(self, scoped_identifier_opt, ScopedIdentifierOpt, context); let identifier = pop_item!(self, identifier, Identifier, context); - let scoped_identifier_group_1_built = ScopedIdentifierGroupIdentifier { + let scoped_identifier_group_1_built = ScopedIdentifierGroupIdentifierScopedIdentifierOpt { identifier: Box::new(identifier), + scoped_identifier_opt, }; let scoped_identifier_group_1_built = - ScopedIdentifierGroup::Identifier(scoped_identifier_group_1_built); + ScopedIdentifierGroup::IdentifierScopedIdentifierOpt(scoped_identifier_group_1_built); self.push( ASTType::ScopedIdentifierGroup(scoped_identifier_group_1_built), context, @@ -19365,24 +19774,28 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 342: + /// Semantic action for production 345: /// - /// `ScopedIdentifierList /* Vec::Push */: ColonColon Identifier ScopedIdentifierList;` + /// `ScopedIdentifierList /* Vec::Push */: ColonColon Identifier ScopedIdentifierOpt0 /* Option */ ScopedIdentifierList;` /// #[parol_runtime::function_name::named] fn scoped_identifier_list_0( &mut self, _colon_colon: &ParseTreeType<'t>, _identifier: &ParseTreeType<'t>, + _scoped_identifier_opt0: &ParseTreeType<'t>, _scoped_identifier_list: &ParseTreeType<'t>, ) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let mut scoped_identifier_list = pop_item!(self, scoped_identifier_list, ScopedIdentifierList, context); + let scoped_identifier_opt0 = + pop_item!(self, scoped_identifier_opt0, ScopedIdentifierOpt0, context); let identifier = pop_item!(self, identifier, Identifier, context); let colon_colon = pop_item!(self, colon_colon, ColonColon, context); let scoped_identifier_list_0_built = ScopedIdentifierList { + scoped_identifier_opt0, identifier: Box::new(identifier), colon_colon: Box::new(colon_colon), }; @@ -19395,7 +19808,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 343: + /// Semantic action for production 346: /// /// `ScopedIdentifierList /* Vec::New */: ;` /// @@ -19411,7 +19824,77 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 344: + /// Semantic action for production 347: + /// + /// `ScopedIdentifierOpt0 /* Option::Some */: WithGenericArgument;` + /// + #[parol_runtime::function_name::named] + fn scoped_identifier_opt0_0( + &mut self, + _with_generic_argument: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_generic_argument = + pop_item!(self, with_generic_argument, WithGenericArgument, context); + let scoped_identifier_opt0_0_built = ScopedIdentifierOpt0 { + with_generic_argument: Box::new(with_generic_argument), + }; + self.push( + ASTType::ScopedIdentifierOpt0(Some(scoped_identifier_opt0_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 348: + /// + /// `ScopedIdentifierOpt0 /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn scoped_identifier_opt0_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::ScopedIdentifierOpt0(None), context); + Ok(()) + } + + /// Semantic action for production 349: + /// + /// `ScopedIdentifierOpt /* Option::Some */: WithGenericArgument;` + /// + #[parol_runtime::function_name::named] + fn scoped_identifier_opt_0( + &mut self, + _with_generic_argument: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_generic_argument = + pop_item!(self, with_generic_argument, WithGenericArgument, context); + let scoped_identifier_opt_0_built = ScopedIdentifierOpt { + with_generic_argument: Box::new(with_generic_argument), + }; + self.push( + ASTType::ScopedIdentifierOpt(Some(scoped_identifier_opt_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 350: + /// + /// `ScopedIdentifierOpt /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn scoped_identifier_opt_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::ScopedIdentifierOpt(None), context); + Ok(()) + } + + /// Semantic action for production 351: /// /// `ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */;` /// @@ -19452,7 +19935,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 345: + /// Semantic action for production 352: /// /// `ExpressionIdentifierList0 /* Vec::Push */: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0;` /// @@ -19494,7 +19977,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 346: + /// Semantic action for production 353: /// /// `ExpressionIdentifierList0List /* Vec::Push */: Select ExpressionIdentifierList0List;` /// @@ -19525,7 +20008,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 347: + /// Semantic action for production 354: /// /// `ExpressionIdentifierList0List /* Vec::New */: ;` /// @@ -19541,7 +20024,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 348: + /// Semantic action for production 355: /// /// `ExpressionIdentifierList0 /* Vec::New */: ;` /// @@ -19557,7 +20040,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 349: + /// Semantic action for production 356: /// /// `ExpressionIdentifierList /* Vec::Push */: Select ExpressionIdentifierList;` /// @@ -19588,7 +20071,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 350: + /// Semantic action for production 357: /// /// `ExpressionIdentifierList /* Vec::New */: ;` /// @@ -19604,7 +20087,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 351: + /// Semantic action for production 358: /// /// `Expression: Expression01 ExpressionList /* Vec */;` /// @@ -19628,7 +20111,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 352: + /// Semantic action for production 359: /// /// `ExpressionList /* Vec::Push */: Operator01 Expression01 ExpressionList;` /// @@ -19654,7 +20137,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 353: + /// Semantic action for production 360: /// /// `ExpressionList /* Vec::New */: ;` /// @@ -19667,7 +20150,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 354: + /// Semantic action for production 361: /// /// `Expression01: Expression02 Expression01List /* Vec */;` /// @@ -19692,7 +20175,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 355: + /// Semantic action for production 362: /// /// `Expression01List /* Vec::Push */: Operator02 Expression02 Expression01List;` /// @@ -19718,7 +20201,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 356: + /// Semantic action for production 363: /// /// `Expression01List /* Vec::New */: ;` /// @@ -19734,7 +20217,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 357: + /// Semantic action for production 364: /// /// `Expression02: Expression03 Expression02List /* Vec */;` /// @@ -19759,7 +20242,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 358: + /// Semantic action for production 365: /// /// `Expression02List /* Vec::Push */: Operator03 Expression03 Expression02List;` /// @@ -19785,7 +20268,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 359: + /// Semantic action for production 366: /// /// `Expression02List /* Vec::New */: ;` /// @@ -19801,7 +20284,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 360: + /// Semantic action for production 367: /// /// `Expression03: Expression04 Expression03List /* Vec */;` /// @@ -19826,7 +20309,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 361: + /// Semantic action for production 368: /// /// `Expression03List /* Vec::Push */: Operator04 Expression04 Expression03List;` /// @@ -19852,7 +20335,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 362: + /// Semantic action for production 369: /// /// `Expression03List /* Vec::New */: ;` /// @@ -19868,7 +20351,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 363: + /// Semantic action for production 370: /// /// `Expression04: Expression05 Expression04List /* Vec */;` /// @@ -19893,7 +20376,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 364: + /// Semantic action for production 371: /// /// `Expression04List /* Vec::Push */: Operator05 Expression05 Expression04List;` /// @@ -19919,7 +20402,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 365: + /// Semantic action for production 372: /// /// `Expression04List /* Vec::New */: ;` /// @@ -19935,7 +20418,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 366: + /// Semantic action for production 373: /// /// `Expression05: Expression06 Expression05List /* Vec */;` /// @@ -19960,7 +20443,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 367: + /// Semantic action for production 374: /// /// `Expression05List /* Vec::Push */: Operator06 Expression06 Expression05List;` /// @@ -19986,7 +20469,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 368: + /// Semantic action for production 375: /// /// `Expression05List /* Vec::New */: ;` /// @@ -20002,7 +20485,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 369: + /// Semantic action for production 376: /// /// `Expression06: Expression07 Expression06List /* Vec */;` /// @@ -20027,7 +20510,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 370: + /// Semantic action for production 377: /// /// `Expression06List /* Vec::Push */: Operator07 Expression07 Expression06List;` /// @@ -20053,7 +20536,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 371: + /// Semantic action for production 378: /// /// `Expression06List /* Vec::New */: ;` /// @@ -20069,7 +20552,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 372: + /// Semantic action for production 379: /// /// `Expression07: Expression08 Expression07List /* Vec */;` /// @@ -20094,7 +20577,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 373: + /// Semantic action for production 380: /// /// `Expression07List /* Vec::Push */: Operator08 Expression08 Expression07List;` /// @@ -20120,7 +20603,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 374: + /// Semantic action for production 381: /// /// `Expression07List /* Vec::New */: ;` /// @@ -20136,7 +20619,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 375: + /// Semantic action for production 382: /// /// `Expression08: Expression09 Expression08List /* Vec */;` /// @@ -20161,7 +20644,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 376: + /// Semantic action for production 383: /// /// `Expression08List /* Vec::Push */: Operator09 Expression09 Expression08List;` /// @@ -20187,7 +20670,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 377: + /// Semantic action for production 384: /// /// `Expression08List /* Vec::New */: ;` /// @@ -20203,7 +20686,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 378: + /// Semantic action for production 385: /// /// `Expression09: Expression10 Expression09List /* Vec */;` /// @@ -20228,7 +20711,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 379: + /// Semantic action for production 386: /// /// `Expression09List /* Vec::Push */: Expression09ListGroup Expression10 Expression09List;` /// @@ -20259,7 +20742,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 380: + /// Semantic action for production 387: /// /// `Expression09ListGroup: Operator10;` /// @@ -20280,7 +20763,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 381: + /// Semantic action for production 388: /// /// `Expression09ListGroup: Star;` /// @@ -20301,7 +20784,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 382: + /// Semantic action for production 389: /// /// `Expression09List /* Vec::New */: ;` /// @@ -20317,7 +20800,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 383: + /// Semantic action for production 390: /// /// `Expression10: Expression11 Expression10List /* Vec */;` /// @@ -20342,7 +20825,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 384: + /// Semantic action for production 391: /// /// `Expression10List /* Vec::Push */: Operator11 Expression11 Expression10List;` /// @@ -20368,7 +20851,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 385: + /// Semantic action for production 392: /// /// `Expression10List /* Vec::New */: ;` /// @@ -20384,7 +20867,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 386: + /// Semantic action for production 393: /// /// `Expression11: Expression12 Expression11List /* Vec */;` /// @@ -20409,7 +20892,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 387: + /// Semantic action for production 394: /// /// `Expression11List /* Vec::Push */: As ScopedIdentifier Expression11List;` /// @@ -20435,7 +20918,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 388: + /// Semantic action for production 395: /// /// `Expression11List /* Vec::New */: ;` /// @@ -20451,7 +20934,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 389: + /// Semantic action for production 396: /// /// `Expression12: Expression12List /* Vec */ Factor;` /// @@ -20476,7 +20959,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 390: + /// Semantic action for production 397: /// /// `Expression12List /* Vec::Push */: Expression12ListGroup Expression12List;` /// @@ -20504,7 +20987,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 391: + /// Semantic action for production 398: /// /// `Expression12ListGroup: UnaryOperator;` /// @@ -20525,7 +21008,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 392: + /// Semantic action for production 399: /// /// `Expression12ListGroup: Operator09;` /// @@ -20546,7 +21029,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 393: + /// Semantic action for production 400: /// /// `Expression12ListGroup: Operator05;` /// @@ -20567,7 +21050,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 394: + /// Semantic action for production 401: /// /// `Expression12ListGroup: Operator03;` /// @@ -20588,7 +21071,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 395: + /// Semantic action for production 402: /// /// `Expression12ListGroup: Operator04;` /// @@ -20609,7 +21092,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 396: + /// Semantic action for production 403: /// /// `Expression12List /* Vec::New */: ;` /// @@ -20625,7 +21108,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 397: + /// Semantic action for production 404: /// /// `Factor: Number;` /// @@ -20644,7 +21127,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 398: + /// Semantic action for production 405: /// /// `Factor: ExpressionIdentifier FactorOpt /* Option */;` /// @@ -20670,7 +21153,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 399: + /// Semantic action for production 406: /// /// `Factor: LParen Expression RParen;` /// @@ -20698,7 +21181,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 400: + /// Semantic action for production 407: /// /// `Factor: LBrace ConcatenationList RBrace;` /// @@ -20726,7 +21209,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 401: + /// Semantic action for production 408: /// /// `Factor: QuoteLBrace ArrayLiteralList RBrace;` /// @@ -20754,7 +21237,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 402: + /// Semantic action for production 409: /// /// `Factor: IfExpression;` /// @@ -20773,7 +21256,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 403: + /// Semantic action for production 410: /// /// `Factor: CaseExpression;` /// @@ -20792,7 +21275,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 404: + /// Semantic action for production 411: /// /// `Factor: StringLiteral;` /// @@ -20811,7 +21294,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 405: + /// Semantic action for production 412: /// /// `Factor: FactorGroup;` /// @@ -20830,7 +21313,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 406: + /// Semantic action for production 413: /// /// `FactorGroup: Msb;` /// @@ -20845,7 +21328,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 407: + /// Semantic action for production 414: /// /// `FactorGroup: Lsb;` /// @@ -20860,7 +21343,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 408: + /// Semantic action for production 415: /// /// `Factor: InsideExpression;` /// @@ -20879,7 +21362,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 409: + /// Semantic action for production 416: /// /// `Factor: OutsideExpression;` /// @@ -20898,7 +21381,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 410: + /// Semantic action for production 417: /// /// `FactorOpt /* Option::Some */: FunctionCall;` /// @@ -20914,7 +21397,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 411: + /// Semantic action for production 418: /// /// `FactorOpt /* Option::None */: ;` /// @@ -20926,7 +21409,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 412: + /// Semantic action for production 419: /// /// `FunctionCall: LParen FunctionCallOpt /* Option */ RParen;` /// @@ -20953,7 +21436,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 413: + /// Semantic action for production 420: /// /// `FunctionCallOpt /* Option::Some */: ArgumentList;` /// @@ -20972,7 +21455,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 414: + /// Semantic action for production 421: /// /// `FunctionCallOpt /* Option::None */: ;` /// @@ -20984,7 +21467,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 415: + /// Semantic action for production 422: /// /// `ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */;` /// @@ -21012,7 +21495,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 416: + /// Semantic action for production 423: /// /// `ArgumentListList /* Vec::Push */: Comma ArgumentItem ArgumentListList;` /// @@ -21038,7 +21521,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 417: + /// Semantic action for production 424: /// /// `ArgumentListList /* Vec::New */: ;` /// @@ -21054,7 +21537,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 418: + /// Semantic action for production 425: /// /// `ArgumentListOpt /* Option::Some */: Comma;` /// @@ -21073,7 +21556,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 419: + /// Semantic action for production 426: /// /// `ArgumentListOpt /* Option::None */: ;` /// @@ -21085,7 +21568,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 420: + /// Semantic action for production 427: /// /// `ArgumentItem: Expression;` /// @@ -21103,7 +21586,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 421: + /// Semantic action for production 428: /// /// `ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */;` /// @@ -21140,7 +21623,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 422: + /// Semantic action for production 429: /// /// `ConcatenationListList /* Vec::Push */: Comma ConcatenationItem ConcatenationListList;` /// @@ -21174,7 +21657,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 423: + /// Semantic action for production 430: /// /// `ConcatenationListList /* Vec::New */: ;` /// @@ -21190,7 +21673,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 424: + /// Semantic action for production 431: /// /// `ConcatenationListOpt /* Option::Some */: Comma;` /// @@ -21209,7 +21692,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 425: + /// Semantic action for production 432: /// /// `ConcatenationListOpt /* Option::None */: ;` /// @@ -21221,7 +21704,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 426: + /// Semantic action for production 433: /// /// `ConcatenationItem: Expression ConcatenationItemOpt /* Option */;` /// @@ -21250,7 +21733,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 427: + /// Semantic action for production 434: /// /// `ConcatenationItemOpt /* Option::Some */: Repeat Expression;` /// @@ -21275,7 +21758,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 428: + /// Semantic action for production 435: /// /// `ConcatenationItemOpt /* Option::None */: ;` /// @@ -21287,7 +21770,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 429: + /// Semantic action for production 436: /// /// `ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */;` /// @@ -21317,7 +21800,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 430: + /// Semantic action for production 437: /// /// `ArrayLiteralListList /* Vec::Push */: Comma ArrayLiteralItem ArrayLiteralListList;` /// @@ -21347,7 +21830,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 431: + /// Semantic action for production 438: /// /// `ArrayLiteralListList /* Vec::New */: ;` /// @@ -21363,7 +21846,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 432: + /// Semantic action for production 439: /// /// `ArrayLiteralListOpt /* Option::Some */: Comma;` /// @@ -21382,7 +21865,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 433: + /// Semantic action for production 440: /// /// `ArrayLiteralListOpt /* Option::None */: ;` /// @@ -21394,7 +21877,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 434: + /// Semantic action for production 441: /// /// `ArrayLiteralItem: ArrayLiteralItemGroup;` /// @@ -21418,7 +21901,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 435: + /// Semantic action for production 442: /// /// `ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */;` /// @@ -21446,7 +21929,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 436: + /// Semantic action for production 443: /// /// `ArrayLiteralItemGroup: Defaul Colon Expression;` /// @@ -21476,7 +21959,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 437: + /// Semantic action for production 444: /// /// `ArrayLiteralItemOpt /* Option::Some */: Repeat Expression;` /// @@ -21501,7 +21984,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 438: + /// Semantic action for production 445: /// /// `ArrayLiteralItemOpt /* Option::None */: ;` /// @@ -21513,7 +21996,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 439: + /// Semantic action for production 446: /// /// `IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace;` /// @@ -21562,7 +22045,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 440: + /// Semantic action for production 447: /// /// `IfExpressionList /* Vec::Push */: Else If Expression LBrace Expression RBrace IfExpressionList;` /// @@ -21600,7 +22083,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 441: + /// Semantic action for production 448: /// /// `IfExpressionList /* Vec::New */: ;` /// @@ -21616,7 +22099,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 442: + /// Semantic action for production 449: /// /// `CaseExpression: Case Expression LBrace Expression CaseExpressionList /* Vec */ Colon Expression Comma CaseExpressionList0 /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace;` /// @@ -21678,7 +22161,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 443: + /// Semantic action for production 450: /// /// `CaseExpressionList0 /* Vec::Push */: Expression CaseExpressionList0List /* Vec */ Colon Expression Comma CaseExpressionList0;` /// @@ -21719,7 +22202,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 444: + /// Semantic action for production 451: /// /// `CaseExpressionList0List /* Vec::Push */: Comma Expression CaseExpressionList0List;` /// @@ -21753,7 +22236,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 445: + /// Semantic action for production 452: /// /// `CaseExpressionList0List /* Vec::New */: ;` /// @@ -21769,7 +22252,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 446: + /// Semantic action for production 453: /// /// `CaseExpressionList0 /* Vec::New */: ;` /// @@ -21785,7 +22268,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 447: + /// Semantic action for production 454: /// /// `CaseExpressionList /* Vec::Push */: Comma Expression CaseExpressionList;` /// @@ -21812,7 +22295,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 448: + /// Semantic action for production 455: /// /// `CaseExpressionList /* Vec::New */: ;` /// @@ -21828,7 +22311,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 449: + /// Semantic action for production 456: /// /// `CaseExpressionOpt /* Option::Some */: Comma;` /// @@ -21847,7 +22330,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 450: + /// Semantic action for production 457: /// /// `CaseExpressionOpt /* Option::None */: ;` /// @@ -21859,7 +22342,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 451: + /// Semantic action for production 458: /// /// `TypeExpression: ScalarType;` /// @@ -21879,7 +22362,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 452: + /// Semantic action for production 459: /// /// `TypeExpression: Type LParen Expression RParen;` /// @@ -21912,7 +22395,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 453: + /// Semantic action for production 460: /// /// `InsideExpression: Inside Expression LBrace RangeList RBrace;` /// @@ -21946,7 +22429,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 454: + /// Semantic action for production 461: /// /// `OutsideExpression: Outside Expression LBrace RangeList RBrace;` /// @@ -21983,7 +22466,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 455: + /// Semantic action for production 462: /// /// `RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */;` /// @@ -22010,7 +22493,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 456: + /// Semantic action for production 463: /// /// `RangeListList /* Vec::Push */: Comma RangeItem RangeListList;` /// @@ -22036,7 +22519,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 457: + /// Semantic action for production 464: /// /// `RangeListList /* Vec::New */: ;` /// @@ -22049,7 +22532,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 458: + /// Semantic action for production 465: /// /// `RangeListOpt /* Option::Some */: Comma;` /// @@ -22065,7 +22548,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 459: + /// Semantic action for production 466: /// /// `RangeListOpt /* Option::None */: ;` /// @@ -22077,7 +22560,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 460: + /// Semantic action for production 467: /// /// `RangeItem: Range;` /// @@ -22095,7 +22578,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 461: + /// Semantic action for production 468: /// /// `Select: LBracket Expression SelectOpt /* Option */ RBracket;` /// @@ -22125,7 +22608,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 462: + /// Semantic action for production 469: /// /// `SelectOpt /* Option::Some */: SelectOperator Expression;` /// @@ -22147,7 +22630,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 463: + /// Semantic action for production 470: /// /// `SelectOpt /* Option::None */: ;` /// @@ -22159,7 +22642,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 464: + /// Semantic action for production 471: /// /// `SelectOperator: Colon;` /// @@ -22179,7 +22662,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 465: + /// Semantic action for production 472: /// /// `SelectOperator: PlusColon;` /// @@ -22199,7 +22682,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 466: + /// Semantic action for production 473: /// /// `SelectOperator: MinusColon;` /// @@ -22219,7 +22702,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 467: + /// Semantic action for production 474: /// /// `SelectOperator: Step;` /// @@ -22239,7 +22722,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 468: + /// Semantic action for production 475: /// /// `Width: LAngle Expression WidthList /* Vec */ RAngle;` /// @@ -22269,7 +22752,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 469: + /// Semantic action for production 476: /// /// `WidthList /* Vec::Push */: Comma Expression WidthList;` /// @@ -22295,7 +22778,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 470: + /// Semantic action for production 477: /// /// `WidthList /* Vec::New */: ;` /// @@ -22308,7 +22791,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 471: + /// Semantic action for production 478: /// /// `Array: LBracket Expression ArrayList /* Vec */ RBracket;` /// @@ -22338,7 +22821,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 472: + /// Semantic action for production 479: /// /// `ArrayList /* Vec::Push */: Comma Expression ArrayList;` /// @@ -22364,7 +22847,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 473: + /// Semantic action for production 480: /// /// `ArrayList /* Vec::New */: ;` /// @@ -22377,7 +22860,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 474: + /// Semantic action for production 481: /// /// `Range: Expression RangeOpt /* Option */;` /// @@ -22401,7 +22884,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 475: + /// Semantic action for production 482: /// /// `RangeOpt /* Option::Some */: RangeOperator Expression;` /// @@ -22423,7 +22906,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 476: + /// Semantic action for production 483: /// /// `RangeOpt /* Option::None */: ;` /// @@ -22435,7 +22918,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 477: + /// Semantic action for production 484: /// /// `RangeOperator: DotDot;` /// @@ -22454,7 +22937,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 478: + /// Semantic action for production 485: /// /// `RangeOperator: DotDotEqu;` /// @@ -22473,7 +22956,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 479: + /// Semantic action for production 486: /// /// `FixedType: U32;` /// @@ -22490,7 +22973,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 480: + /// Semantic action for production 487: /// /// `FixedType: U64;` /// @@ -22507,7 +22990,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 481: + /// Semantic action for production 488: /// /// `FixedType: I32;` /// @@ -22524,7 +23007,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 482: + /// Semantic action for production 489: /// /// `FixedType: I64;` /// @@ -22541,7 +23024,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 483: + /// Semantic action for production 490: /// /// `FixedType: F32;` /// @@ -22558,7 +23041,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 484: + /// Semantic action for production 491: /// /// `FixedType: F64;` /// @@ -22575,7 +23058,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 485: + /// Semantic action for production 492: /// /// `FixedType: Strin;` /// @@ -22594,7 +23077,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 486: + /// Semantic action for production 493: /// /// `VariableType: VariableTypeGroup VariableTypeOpt /* Option */;` /// @@ -22618,7 +23101,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 487: + /// Semantic action for production 494: /// /// `VariableTypeGroup: Clock;` /// @@ -22638,7 +23121,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 488: + /// Semantic action for production 495: /// /// `VariableTypeGroup: ClockPosedge;` /// @@ -22659,7 +23142,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 489: + /// Semantic action for production 496: /// /// `VariableTypeGroup: ClockNegedge;` /// @@ -22680,7 +23163,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 490: + /// Semantic action for production 497: /// /// `VariableTypeGroup: Reset;` /// @@ -22700,7 +23183,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 491: + /// Semantic action for production 498: /// /// `VariableTypeGroup: ResetAsyncHigh;` /// @@ -22721,7 +23204,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 492: + /// Semantic action for production 499: /// /// `VariableTypeGroup: ResetAsyncLow;` /// @@ -22742,7 +23225,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 493: + /// Semantic action for production 500: /// /// `VariableTypeGroup: ResetSyncHigh;` /// @@ -22763,7 +23246,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 494: + /// Semantic action for production 501: /// /// `VariableTypeGroup: ResetSyncLow;` /// @@ -22784,7 +23267,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 495: + /// Semantic action for production 502: /// /// `VariableTypeGroup: Logic;` /// @@ -22804,7 +23287,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 496: + /// Semantic action for production 503: /// /// `VariableTypeGroup: Bit;` /// @@ -22822,7 +23305,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 497: + /// Semantic action for production 504: /// /// `VariableTypeGroup: ScopedIdentifier;` /// @@ -22843,7 +23326,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 498: + /// Semantic action for production 505: /// /// `VariableTypeOpt /* Option::Some */: Width;` /// @@ -22862,7 +23345,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 499: + /// Semantic action for production 506: /// /// `VariableTypeOpt /* Option::None */: ;` /// @@ -22874,7 +23357,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 500: + /// Semantic action for production 507: /// /// `TypeModifier: Tri;` /// @@ -22891,7 +23374,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 501: + /// Semantic action for production 508: /// /// `TypeModifier: Signed;` /// @@ -22910,7 +23393,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 502: + /// Semantic action for production 509: /// /// `ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup;` /// @@ -22935,7 +23418,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 503: + /// Semantic action for production 510: /// /// `ScalarTypeGroup: VariableType;` /// @@ -22952,7 +23435,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 504: + /// Semantic action for production 511: /// /// `ScalarTypeGroup: FixedType;` /// @@ -22969,7 +23452,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 505: + /// Semantic action for production 512: /// /// `ScalarTypeList /* Vec::Push */: TypeModifier ScalarTypeList;` /// @@ -22992,7 +23475,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 506: + /// Semantic action for production 513: /// /// `ScalarTypeList /* Vec::New */: ;` /// @@ -23005,7 +23488,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 507: + /// Semantic action for production 514: /// /// `ArrayType: ScalarType ArrayTypeOpt /* Option */;` /// @@ -23029,7 +23512,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 508: + /// Semantic action for production 515: /// /// `ArrayTypeOpt /* Option::Some */: Array;` /// @@ -23045,7 +23528,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 509: + /// Semantic action for production 516: /// /// `ArrayTypeOpt /* Option::None */: ;` /// @@ -23057,7 +23540,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 510: + /// Semantic action for production 517: /// /// `Statement: LetStatement;` /// @@ -23076,7 +23559,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 511: + /// Semantic action for production 518: /// /// `Statement: IdentifierStatement;` /// @@ -23096,7 +23579,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 512: + /// Semantic action for production 519: /// /// `Statement: IfStatement;` /// @@ -23115,7 +23598,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 513: + /// Semantic action for production 520: /// /// `Statement: IfResetStatement;` /// @@ -23134,7 +23617,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 514: + /// Semantic action for production 521: /// /// `Statement: ReturnStatement;` /// @@ -23153,7 +23636,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 515: + /// Semantic action for production 522: /// /// `Statement: BreakStatement;` /// @@ -23172,7 +23655,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 516: + /// Semantic action for production 523: /// /// `Statement: ForStatement;` /// @@ -23191,7 +23674,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 517: + /// Semantic action for production 524: /// /// `Statement: CaseStatement;` /// @@ -23210,7 +23693,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 518: + /// Semantic action for production 525: /// /// `LetStatement: Let Identifier Colon ArrayType Equ Expression Semicolon;` /// @@ -23249,7 +23732,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 519: + /// Semantic action for production 526: /// /// `IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon;` /// @@ -23286,7 +23769,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 520: + /// Semantic action for production 527: /// /// `IdentifierStatementGroup: FunctionCall;` /// @@ -23307,7 +23790,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 521: + /// Semantic action for production 528: /// /// `IdentifierStatementGroup: Assignment;` /// @@ -23328,7 +23811,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 522: + /// Semantic action for production 529: /// /// `Assignment: AssignmentGroup Expression;` /// @@ -23352,7 +23835,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 523: + /// Semantic action for production 530: /// /// `AssignmentGroup: Equ;` /// @@ -23367,7 +23850,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 524: + /// Semantic action for production 531: /// /// `AssignmentGroup: AssignmentOperator;` /// @@ -23385,7 +23868,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 525: + /// Semantic action for production 532: /// /// `IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */;` /// @@ -23426,7 +23909,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 526: + /// Semantic action for production 533: /// /// `IfStatementList0 /* Vec::Push */: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0;` /// @@ -23465,7 +23948,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 527: + /// Semantic action for production 534: /// /// `IfStatementList0List /* Vec::Push */: Statement IfStatementList0List;` /// @@ -23492,7 +23975,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 528: + /// Semantic action for production 535: /// /// `IfStatementList0List /* Vec::New */: ;` /// @@ -23508,7 +23991,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 529: + /// Semantic action for production 536: /// /// `IfStatementList0 /* Vec::New */: ;` /// @@ -23524,7 +24007,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 530: + /// Semantic action for production 537: /// /// `IfStatementList /* Vec::Push */: Statement IfStatementList;` /// @@ -23547,7 +24030,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 531: + /// Semantic action for production 538: /// /// `IfStatementList /* Vec::New */: ;` /// @@ -23560,7 +24043,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 532: + /// Semantic action for production 539: /// /// `IfStatementOpt /* Option::Some */: Else LBrace IfStatementOptList /* Vec */ RBrace;` /// @@ -23592,7 +24075,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 533: + /// Semantic action for production 540: /// /// `IfStatementOptList /* Vec::Push */: Statement IfStatementOptList;` /// @@ -23616,7 +24099,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 534: + /// Semantic action for production 541: /// /// `IfStatementOptList /* Vec::New */: ;` /// @@ -23632,7 +24115,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 535: + /// Semantic action for production 542: /// /// `IfStatementOpt /* Option::None */: ;` /// @@ -23644,7 +24127,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 536: + /// Semantic action for production 543: /// /// `IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */;` /// @@ -23688,7 +24171,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 537: + /// Semantic action for production 544: /// /// `IfResetStatementList0 /* Vec::Push */: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0;` /// @@ -23739,7 +24222,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 538: + /// Semantic action for production 545: /// /// `IfResetStatementList0List /* Vec::Push */: Statement IfResetStatementList0List;` /// @@ -23770,7 +24253,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 539: + /// Semantic action for production 546: /// /// `IfResetStatementList0List /* Vec::New */: ;` /// @@ -23786,7 +24269,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 540: + /// Semantic action for production 547: /// /// `IfResetStatementList0 /* Vec::New */: ;` /// @@ -23802,7 +24285,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 541: + /// Semantic action for production 548: /// /// `IfResetStatementList /* Vec::Push */: Statement IfResetStatementList;` /// @@ -23829,7 +24312,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 542: + /// Semantic action for production 549: /// /// `IfResetStatementList /* Vec::New */: ;` /// @@ -23845,7 +24328,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 543: + /// Semantic action for production 550: /// /// `IfResetStatementOpt /* Option::Some */: Else LBrace IfResetStatementOptList /* Vec */ RBrace;` /// @@ -23881,7 +24364,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 544: + /// Semantic action for production 551: /// /// `IfResetStatementOptList /* Vec::Push */: Statement IfResetStatementOptList;` /// @@ -23912,7 +24395,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 545: + /// Semantic action for production 552: /// /// `IfResetStatementOptList /* Vec::New */: ;` /// @@ -23928,7 +24411,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 546: + /// Semantic action for production 553: /// /// `IfResetStatementOpt /* Option::None */: ;` /// @@ -23940,7 +24423,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 547: + /// Semantic action for production 554: /// /// `ReturnStatement: Return Expression Semicolon;` /// @@ -23968,7 +24451,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 548: + /// Semantic action for production 555: /// /// `BreakStatement: Break Semicolon;` /// @@ -23992,7 +24475,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 549: + /// Semantic action for production 556: /// /// `ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace;` /// @@ -24041,7 +24524,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 550: + /// Semantic action for production 557: /// /// `ForStatementList /* Vec::Push */: Statement ForStatementList;` /// @@ -24064,7 +24547,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 551: + /// Semantic action for production 558: /// /// `ForStatementList /* Vec::New */: ;` /// @@ -24080,7 +24563,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 552: + /// Semantic action for production 559: /// /// `ForStatementOpt /* Option::Some */: Step AssignmentOperator Expression;` /// @@ -24108,7 +24591,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 553: + /// Semantic action for production 560: /// /// `ForStatementOpt /* Option::None */: ;` /// @@ -24120,7 +24603,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 554: + /// Semantic action for production 561: /// /// `CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace;` /// @@ -24154,7 +24637,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 555: + /// Semantic action for production 562: /// /// `CaseStatementList /* Vec::Push */: CaseItem CaseStatementList;` /// @@ -24178,7 +24661,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 556: + /// Semantic action for production 563: /// /// `CaseStatementList /* Vec::New */: ;` /// @@ -24194,7 +24677,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 557: + /// Semantic action for production 564: /// /// `CaseItem: CaseItemGroup Colon CaseItemGroup0;` /// @@ -24221,7 +24704,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 558: + /// Semantic action for production 565: /// /// `CaseItemGroup0: Statement;` /// @@ -24238,7 +24721,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 559: + /// Semantic action for production 566: /// /// `CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace;` /// @@ -24266,7 +24749,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 560: + /// Semantic action for production 567: /// /// `CaseItemGroup0List /* Vec::Push */: Statement CaseItemGroup0List;` /// @@ -24290,7 +24773,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 561: + /// Semantic action for production 568: /// /// `CaseItemGroup0List /* Vec::New */: ;` /// @@ -24306,7 +24789,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 562: + /// Semantic action for production 569: /// /// `CaseItemGroup: Expression CaseItemGroupList /* Vec */;` /// @@ -24331,7 +24814,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 563: + /// Semantic action for production 570: /// /// `CaseItemGroupList /* Vec::Push */: Comma Expression CaseItemGroupList;` /// @@ -24358,7 +24841,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 564: + /// Semantic action for production 571: /// /// `CaseItemGroupList /* Vec::New */: ;` /// @@ -24374,7 +24857,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 565: + /// Semantic action for production 572: /// /// `CaseItemGroup: Defaul;` /// @@ -24391,7 +24874,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 566: + /// Semantic action for production 573: /// /// `Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket;` /// @@ -24424,7 +24907,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 567: + /// Semantic action for production 574: /// /// `AttributeOpt /* Option::Some */: LParen AttributeList RParen;` /// @@ -24449,7 +24932,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 568: + /// Semantic action for production 575: /// /// `AttributeOpt /* Option::None */: ;` /// @@ -24461,7 +24944,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 569: + /// Semantic action for production 576: /// /// `AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */;` /// @@ -24489,7 +24972,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 570: + /// Semantic action for production 577: /// /// `AttributeListList /* Vec::Push */: Comma AttributeItem AttributeListList;` /// @@ -24516,7 +24999,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 571: + /// Semantic action for production 578: /// /// `AttributeListList /* Vec::New */: ;` /// @@ -24532,7 +25015,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 572: + /// Semantic action for production 579: /// /// `AttributeListOpt /* Option::Some */: Comma;` /// @@ -24551,7 +25034,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 573: + /// Semantic action for production 580: /// /// `AttributeListOpt /* Option::None */: ;` /// @@ -24563,7 +25046,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 574: + /// Semantic action for production 581: /// /// `AttributeItem: Identifier;` /// @@ -24582,7 +25065,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 575: + /// Semantic action for production 582: /// /// `AttributeItem: StringLiteral;` /// @@ -24601,7 +25084,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 576: + /// Semantic action for production 583: /// /// `LetDeclaration: Let Identifier Colon ArrayType Equ Expression Semicolon;` /// @@ -24640,7 +25123,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 577: + /// Semantic action for production 584: /// /// `VarDeclaration: Var Identifier Colon ArrayType Semicolon;` /// @@ -24673,7 +25156,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 578: + /// Semantic action for production 585: /// /// `LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon;` /// @@ -24712,7 +25195,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 579: + /// Semantic action for production 586: /// /// `LocalDeclarationGroup: ArrayType Equ Expression;` /// @@ -24742,7 +25225,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 580: + /// Semantic action for production 587: /// /// `LocalDeclarationGroup: Type Equ TypeExpression;` /// @@ -24772,7 +25255,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 581: + /// Semantic action for production 588: /// /// `TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon;` /// @@ -24809,7 +25292,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 582: + /// Semantic action for production 589: /// /// `AlwaysFfDeclaration: AlwaysFf LParen AlwaysFfClock AlwaysFfDeclarationOpt /* Option */ RParen LBrace AlwaysFfDeclarationList /* Vec */ RBrace;` /// @@ -24865,7 +25348,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 583: + /// Semantic action for production 590: /// /// `AlwaysFfDeclarationList /* Vec::Push */: Statement AlwaysFfDeclarationList;` /// @@ -24896,7 +25379,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 584: + /// Semantic action for production 591: /// /// `AlwaysFfDeclarationList /* Vec::New */: ;` /// @@ -24912,7 +25395,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 585: + /// Semantic action for production 592: /// /// `AlwaysFfDeclarationOpt /* Option::Some */: Comma AlwaysFfReset;` /// @@ -24937,7 +25420,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 586: + /// Semantic action for production 593: /// /// `AlwaysFfDeclarationOpt /* Option::None */: ;` /// @@ -24949,7 +25432,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 587: + /// Semantic action for production 594: /// /// `AlwaysFfClock: HierarchicalIdentifier;` /// @@ -24972,7 +25455,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 588: + /// Semantic action for production 595: /// /// `AlwaysFfReset: HierarchicalIdentifier;` /// @@ -24995,7 +25478,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 589: + /// Semantic action for production 596: /// /// `AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace;` /// @@ -25034,7 +25517,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 590: + /// Semantic action for production 597: /// /// `AlwaysCombDeclarationList /* Vec::Push */: Statement AlwaysCombDeclarationList;` /// @@ -25065,7 +25548,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 591: + /// Semantic action for production 598: /// /// `AlwaysCombDeclarationList /* Vec::New */: ;` /// @@ -25081,7 +25564,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 592: + /// Semantic action for production 599: /// /// `AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon;` /// @@ -25123,7 +25606,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 593: + /// Semantic action for production 600: /// /// `ModportDeclaration: Modport Identifier LBrace ModportList RBrace;` /// @@ -25160,7 +25643,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 594: + /// Semantic action for production 601: /// /// `ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */;` /// @@ -25188,7 +25671,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 595: + /// Semantic action for production 602: /// /// `ModportListList /* Vec::Push */: Comma ModportGroup ModportListList;` /// @@ -25214,7 +25697,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 596: + /// Semantic action for production 603: /// /// `ModportListList /* Vec::New */: ;` /// @@ -25227,7 +25710,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 597: + /// Semantic action for production 604: /// /// `ModportListOpt /* Option::Some */: Comma;` /// @@ -25246,7 +25729,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 598: + /// Semantic action for production 605: /// /// `ModportListOpt /* Option::None */: ;` /// @@ -25258,7 +25741,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 599: + /// Semantic action for production 606: /// /// `ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup;` /// @@ -25283,7 +25766,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 600: + /// Semantic action for production 607: /// /// `ModportGroupGroup: LBrace ModportList RBrace;` /// @@ -25313,7 +25796,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 601: + /// Semantic action for production 608: /// /// `ModportGroupGroup: ModportItem;` /// @@ -25334,7 +25817,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 602: + /// Semantic action for production 609: /// /// `ModportGroupList /* Vec::Push */: Attribute ModportGroupList;` /// @@ -25357,7 +25840,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 603: + /// Semantic action for production 610: /// /// `ModportGroupList /* Vec::New */: ;` /// @@ -25373,7 +25856,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 604: + /// Semantic action for production 611: /// /// `ModportItem: Identifier Colon Direction;` /// @@ -25400,7 +25883,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 605: + /// Semantic action for production 612: /// /// `EnumDeclaration: Enum Identifier Colon ScalarType LBrace EnumList RBrace;` /// @@ -25440,7 +25923,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 606: + /// Semantic action for production 613: /// /// `EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */;` /// @@ -25467,7 +25950,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 607: + /// Semantic action for production 614: /// /// `EnumListList /* Vec::Push */: Comma EnumGroup EnumListList;` /// @@ -25493,7 +25976,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 608: + /// Semantic action for production 615: /// /// `EnumListList /* Vec::New */: ;` /// @@ -25506,7 +25989,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 609: + /// Semantic action for production 616: /// /// `EnumListOpt /* Option::Some */: Comma;` /// @@ -25522,7 +26005,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 610: + /// Semantic action for production 617: /// /// `EnumListOpt /* Option::None */: ;` /// @@ -25534,7 +26017,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 611: + /// Semantic action for production 618: /// /// `EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup;` /// @@ -25558,7 +26041,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 612: + /// Semantic action for production 619: /// /// `EnumGroupGroup: LBrace EnumList RBrace;` /// @@ -25585,7 +26068,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 613: + /// Semantic action for production 620: /// /// `EnumGroupGroup: EnumItem;` /// @@ -25602,7 +26085,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 614: + /// Semantic action for production 621: /// /// `EnumGroupList /* Vec::Push */: Attribute EnumGroupList;` /// @@ -25625,7 +26108,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 615: + /// Semantic action for production 622: /// /// `EnumGroupList /* Vec::New */: ;` /// @@ -25638,7 +26121,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 616: + /// Semantic action for production 623: /// /// `EnumItem: Identifier EnumItemOpt /* Option */;` /// @@ -25662,7 +26145,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 617: + /// Semantic action for production 624: /// /// `EnumItemOpt /* Option::Some */: Equ Expression;` /// @@ -25684,7 +26167,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 618: + /// Semantic action for production 625: /// /// `EnumItemOpt /* Option::None */: ;` /// @@ -25696,7 +26179,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 619: + /// Semantic action for production 626: /// /// `StructUnion: Struct;` /// @@ -25715,7 +26198,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 620: + /// Semantic action for production 627: /// /// `StructUnion: Union;` /// @@ -25734,15 +26217,16 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 621: + /// Semantic action for production 628: /// - /// `StructUnionDeclaration: StructUnion Identifier LBrace StructUnionList RBrace;` + /// `StructUnionDeclaration: StructUnion Identifier StructUnionDeclarationOpt /* Option */ LBrace StructUnionList RBrace;` /// #[parol_runtime::function_name::named] fn struct_union_declaration( &mut self, _struct_union: &ParseTreeType<'t>, _identifier: &ParseTreeType<'t>, + _struct_union_declaration_opt: &ParseTreeType<'t>, _l_brace: &ParseTreeType<'t>, _struct_union_list: &ParseTreeType<'t>, _r_brace: &ParseTreeType<'t>, @@ -25752,11 +26236,18 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { let r_brace = pop_item!(self, r_brace, RBrace, context); let struct_union_list = pop_item!(self, struct_union_list, StructUnionList, context); let l_brace = pop_item!(self, l_brace, LBrace, context); + let struct_union_declaration_opt = pop_item!( + self, + struct_union_declaration_opt, + StructUnionDeclarationOpt, + context + ); let identifier = pop_item!(self, identifier, Identifier, context); let struct_union = pop_item!(self, struct_union, StructUnion, context); let struct_union_declaration_built = StructUnionDeclaration { struct_union: Box::new(struct_union), identifier: Box::new(identifier), + struct_union_declaration_opt, l_brace: Box::new(l_brace), struct_union_list: Box::new(struct_union_list), r_brace: Box::new(r_brace), @@ -25771,7 +26262,42 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 622: + /// Semantic action for production 629: + /// + /// `StructUnionDeclarationOpt /* Option::Some */: WithGenericParameter;` + /// + #[parol_runtime::function_name::named] + fn struct_union_declaration_opt_0( + &mut self, + _with_generic_parameter: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_generic_parameter = + pop_item!(self, with_generic_parameter, WithGenericParameter, context); + let struct_union_declaration_opt_0_built = StructUnionDeclarationOpt { + with_generic_parameter: Box::new(with_generic_parameter), + }; + self.push( + ASTType::StructUnionDeclarationOpt(Some(struct_union_declaration_opt_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 630: + /// + /// `StructUnionDeclarationOpt /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn struct_union_declaration_opt_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::StructUnionDeclarationOpt(None), context); + Ok(()) + } + + /// Semantic action for production 631: /// /// `StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */;` /// @@ -25801,7 +26327,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 623: + /// Semantic action for production 632: /// /// `StructUnionListList /* Vec::Push */: Comma StructUnionGroup StructUnionListList;` /// @@ -25831,7 +26357,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 624: + /// Semantic action for production 633: /// /// `StructUnionListList /* Vec::New */: ;` /// @@ -25847,7 +26373,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 625: + /// Semantic action for production 634: /// /// `StructUnionListOpt /* Option::Some */: Comma;` /// @@ -25866,7 +26392,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 626: + /// Semantic action for production 635: /// /// `StructUnionListOpt /* Option::None */: ;` /// @@ -25878,7 +26404,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 627: + /// Semantic action for production 636: /// /// `StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup;` /// @@ -25909,7 +26435,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 628: + /// Semantic action for production 637: /// /// `StructUnionGroupGroup: LBrace StructUnionList RBrace;` /// @@ -25939,7 +26465,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 629: + /// Semantic action for production 638: /// /// `StructUnionGroupGroup: StructUnionItem;` /// @@ -25960,7 +26486,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 630: + /// Semantic action for production 639: /// /// `StructUnionGroupList /* Vec::Push */: Attribute StructUnionGroupList;` /// @@ -25987,7 +26513,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 631: + /// Semantic action for production 640: /// /// `StructUnionGroupList /* Vec::New */: ;` /// @@ -26003,7 +26529,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 632: + /// Semantic action for production 641: /// /// `StructUnionItem: Identifier Colon ScalarType;` /// @@ -26031,7 +26557,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 633: + /// Semantic action for production 642: /// /// `InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace;` /// @@ -26070,7 +26596,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 634: + /// Semantic action for production 643: /// /// `InitialDeclarationList /* Vec::Push */: Statement InitialDeclarationList;` /// @@ -26101,7 +26627,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 635: + /// Semantic action for production 644: /// /// `InitialDeclarationList /* Vec::New */: ;` /// @@ -26117,7 +26643,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 636: + /// Semantic action for production 645: /// /// `FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace;` /// @@ -26149,7 +26675,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 637: + /// Semantic action for production 646: /// /// `FinalDeclarationList /* Vec::Push */: Statement FinalDeclarationList;` /// @@ -26176,7 +26702,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 638: + /// Semantic action for production 647: /// /// `FinalDeclarationList /* Vec::New */: ;` /// @@ -26192,7 +26718,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 639: + /// Semantic action for production 648: /// /// `InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon;` /// @@ -26238,7 +26764,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 640: + /// Semantic action for production 649: /// /// `InstDeclarationOpt1 /* Option::Some */: LParen InstDeclarationOpt2 /* Option */ RParen;` /// @@ -26267,7 +26793,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 641: + /// Semantic action for production 650: /// /// `InstDeclarationOpt2 /* Option::Some */: InstPortList;` /// @@ -26286,7 +26812,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 642: + /// Semantic action for production 651: /// /// `InstDeclarationOpt2 /* Option::None */: ;` /// @@ -26298,7 +26824,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 643: + /// Semantic action for production 652: /// /// `InstDeclarationOpt1 /* Option::None */: ;` /// @@ -26310,7 +26836,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 644: + /// Semantic action for production 653: /// /// `InstDeclarationOpt0 /* Option::Some */: InstParameter;` /// @@ -26329,7 +26855,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 645: + /// Semantic action for production 654: /// /// `InstDeclarationOpt0 /* Option::None */: ;` /// @@ -26341,7 +26867,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 646: + /// Semantic action for production 655: /// /// `InstDeclarationOpt /* Option::Some */: Array;` /// @@ -26360,7 +26886,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 647: + /// Semantic action for production 656: /// /// `InstDeclarationOpt /* Option::None */: ;` /// @@ -26372,7 +26898,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 648: + /// Semantic action for production 657: /// /// `InstParameter: Hash LParen InstParameterOpt /* Option */ RParen;` /// @@ -26402,7 +26928,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 649: + /// Semantic action for production 658: /// /// `InstParameterOpt /* Option::Some */: InstParameterList;` /// @@ -26421,7 +26947,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 650: + /// Semantic action for production 659: /// /// `InstParameterOpt /* Option::None */: ;` /// @@ -26433,7 +26959,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 651: + /// Semantic action for production 660: /// /// `InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */;` /// @@ -26471,7 +26997,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 652: + /// Semantic action for production 661: /// /// `InstParameterListList /* Vec::Push */: Comma InstParameterGroup InstParameterListList;` /// @@ -26506,7 +27032,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 653: + /// Semantic action for production 662: /// /// `InstParameterListList /* Vec::New */: ;` /// @@ -26522,7 +27048,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 654: + /// Semantic action for production 663: /// /// `InstParameterListOpt /* Option::Some */: Comma;` /// @@ -26541,7 +27067,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 655: + /// Semantic action for production 664: /// /// `InstParameterListOpt /* Option::None */: ;` /// @@ -26553,7 +27079,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 656: + /// Semantic action for production 665: /// /// `InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup;` /// @@ -26591,7 +27117,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 657: + /// Semantic action for production 666: /// /// `InstParameterGroupGroup: LBrace InstParameterList RBrace;` /// @@ -26624,7 +27150,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 658: + /// Semantic action for production 667: /// /// `InstParameterGroupGroup: InstParameterItem;` /// @@ -26648,7 +27174,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 659: + /// Semantic action for production 668: /// /// `InstParameterGroupList /* Vec::Push */: Attribute InstParameterGroupList;` /// @@ -26679,7 +27205,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 660: + /// Semantic action for production 669: /// /// `InstParameterGroupList /* Vec::New */: ;` /// @@ -26695,7 +27221,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 661: + /// Semantic action for production 670: /// /// `InstParameterItem: Identifier InstParameterItemOpt /* Option */;` /// @@ -26724,7 +27250,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 662: + /// Semantic action for production 671: /// /// `InstParameterItemOpt /* Option::Some */: Colon Expression;` /// @@ -26749,7 +27275,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 663: + /// Semantic action for production 672: /// /// `InstParameterItemOpt /* Option::None */: ;` /// @@ -26761,7 +27287,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 664: + /// Semantic action for production 673: /// /// `InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */;` /// @@ -26789,7 +27315,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 665: + /// Semantic action for production 674: /// /// `InstPortListList /* Vec::Push */: Comma InstPortGroup InstPortListList;` /// @@ -26816,7 +27342,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 666: + /// Semantic action for production 675: /// /// `InstPortListList /* Vec::New */: ;` /// @@ -26832,7 +27358,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 667: + /// Semantic action for production 676: /// /// `InstPortListOpt /* Option::Some */: Comma;` /// @@ -26851,7 +27377,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 668: + /// Semantic action for production 677: /// /// `InstPortListOpt /* Option::None */: ;` /// @@ -26863,7 +27389,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 669: + /// Semantic action for production 678: /// /// `InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup;` /// @@ -26889,7 +27415,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 670: + /// Semantic action for production 679: /// /// `InstPortGroupGroup: LBrace InstPortList RBrace;` /// @@ -26919,7 +27445,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 671: + /// Semantic action for production 680: /// /// `InstPortGroupGroup: InstPortItem;` /// @@ -26940,7 +27466,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 672: + /// Semantic action for production 681: /// /// `InstPortGroupList /* Vec::Push */: Attribute InstPortGroupList;` /// @@ -26964,7 +27490,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 673: + /// Semantic action for production 682: /// /// `InstPortGroupList /* Vec::New */: ;` /// @@ -26980,7 +27506,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 674: + /// Semantic action for production 683: /// /// `InstPortItem: Identifier InstPortItemOpt /* Option */;` /// @@ -27004,7 +27530,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 675: + /// Semantic action for production 684: /// /// `InstPortItemOpt /* Option::Some */: Colon Expression;` /// @@ -27029,7 +27555,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 676: + /// Semantic action for production 685: /// /// `InstPortItemOpt /* Option::None */: ;` /// @@ -27041,7 +27567,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 677: + /// Semantic action for production 686: /// /// `WithParameter: Hash LParen WithParameterOpt /* Option */ RParen;` /// @@ -27071,7 +27597,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 678: + /// Semantic action for production 687: /// /// `WithParameterOpt /* Option::Some */: WithParameterList;` /// @@ -27090,7 +27616,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 679: + /// Semantic action for production 688: /// /// `WithParameterOpt /* Option::None */: ;` /// @@ -27102,7 +27628,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 680: + /// Semantic action for production 689: /// /// `WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */;` /// @@ -27140,7 +27666,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 681: + /// Semantic action for production 690: /// /// `WithParameterListList /* Vec::Push */: Comma WithParameterGroup WithParameterListList;` /// @@ -27175,7 +27701,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 682: + /// Semantic action for production 691: /// /// `WithParameterListList /* Vec::New */: ;` /// @@ -27191,7 +27717,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 683: + /// Semantic action for production 692: /// /// `WithParameterListOpt /* Option::Some */: Comma;` /// @@ -27210,7 +27736,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 684: + /// Semantic action for production 693: /// /// `WithParameterListOpt /* Option::None */: ;` /// @@ -27222,7 +27748,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 685: + /// Semantic action for production 694: /// /// `WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup;` /// @@ -27260,7 +27786,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 686: + /// Semantic action for production 695: /// /// `WithParameterGroupGroup: LBrace WithParameterList RBrace;` /// @@ -27293,7 +27819,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 687: + /// Semantic action for production 696: /// /// `WithParameterGroupGroup: WithParameterItem;` /// @@ -27317,7 +27843,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 688: + /// Semantic action for production 697: /// /// `WithParameterGroupList /* Vec::Push */: Attribute WithParameterGroupList;` /// @@ -27348,7 +27874,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 689: + /// Semantic action for production 698: /// /// `WithParameterGroupList /* Vec::New */: ;` /// @@ -27364,7 +27890,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 690: + /// Semantic action for production 699: /// /// `WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0;` /// @@ -27408,7 +27934,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 691: + /// Semantic action for production 700: /// /// `WithParameterItemGroup0: ArrayType Equ Expression;` /// @@ -27438,7 +27964,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 692: + /// Semantic action for production 701: /// /// `WithParameterItemGroup0: Type Equ TypeExpression;` /// @@ -27459,58 +27985,467 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { equ: Box::new(equ), type_expression: Box::new(type_expression), }; - let with_parameter_item_group0_1_built = - WithParameterItemGroup0::TypeEquTypeExpression(with_parameter_item_group0_1_built); + let with_parameter_item_group0_1_built = + WithParameterItemGroup0::TypeEquTypeExpression(with_parameter_item_group0_1_built); + self.push( + ASTType::WithParameterItemGroup0(with_parameter_item_group0_1_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 702: + /// + /// `WithParameterItemGroup: Param;` + /// + #[parol_runtime::function_name::named] + fn with_parameter_item_group_0(&mut self, _param: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let param = pop_item!(self, param, Param, context); + let with_parameter_item_group_0_built = WithParameterItemGroupParam { + param: Box::new(param), + }; + let with_parameter_item_group_0_built = + WithParameterItemGroup::Param(with_parameter_item_group_0_built); + self.push( + ASTType::WithParameterItemGroup(with_parameter_item_group_0_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 703: + /// + /// `WithParameterItemGroup: Local;` + /// + #[parol_runtime::function_name::named] + fn with_parameter_item_group_1(&mut self, _local: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let local = pop_item!(self, local, Local, context); + let with_parameter_item_group_1_built = WithParameterItemGroupLocal { + local: Box::new(local), + }; + let with_parameter_item_group_1_built = + WithParameterItemGroup::Local(with_parameter_item_group_1_built); + self.push( + ASTType::WithParameterItemGroup(with_parameter_item_group_1_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 704: + /// + /// `WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle;` + /// + #[parol_runtime::function_name::named] + fn with_generic_parameter( + &mut self, + _colon_colon_l_angle: &ParseTreeType<'t>, + _with_generic_parameter_list: &ParseTreeType<'t>, + _r_angle: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let r_angle = pop_item!(self, r_angle, RAngle, context); + let with_generic_parameter_list = pop_item!( + self, + with_generic_parameter_list, + WithGenericParameterList, + context + ); + let colon_colon_l_angle = pop_item!(self, colon_colon_l_angle, ColonColonLAngle, context); + let with_generic_parameter_built = WithGenericParameter { + colon_colon_l_angle: Box::new(colon_colon_l_angle), + with_generic_parameter_list: Box::new(with_generic_parameter_list), + r_angle: Box::new(r_angle), + }; + // Calling user action here + self.user_grammar + .with_generic_parameter(&with_generic_parameter_built)?; + self.push( + ASTType::WithGenericParameter(with_generic_parameter_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 705: + /// + /// `WithGenericParameterList: WithGenericParameterItem WithGenericParameterListList /* Vec */ WithGenericParameterListOpt /* Option */;` + /// + #[parol_runtime::function_name::named] + fn with_generic_parameter_list( + &mut self, + _with_generic_parameter_item: &ParseTreeType<'t>, + _with_generic_parameter_list_list: &ParseTreeType<'t>, + _with_generic_parameter_list_opt: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_generic_parameter_list_opt = pop_item!( + self, + with_generic_parameter_list_opt, + WithGenericParameterListOpt, + context + ); + let with_generic_parameter_list_list = pop_and_reverse_item!( + self, + with_generic_parameter_list_list, + WithGenericParameterListList, + context + ); + let with_generic_parameter_item = pop_item!( + self, + with_generic_parameter_item, + WithGenericParameterItem, + context + ); + let with_generic_parameter_list_built = WithGenericParameterList { + with_generic_parameter_item: Box::new(with_generic_parameter_item), + with_generic_parameter_list_list, + with_generic_parameter_list_opt, + }; + // Calling user action here + self.user_grammar + .with_generic_parameter_list(&with_generic_parameter_list_built)?; + self.push( + ASTType::WithGenericParameterList(with_generic_parameter_list_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 706: + /// + /// `WithGenericParameterListList /* Vec::Push */: Comma WithGenericParameterItem WithGenericParameterListList;` + /// + #[parol_runtime::function_name::named] + fn with_generic_parameter_list_list_0( + &mut self, + _comma: &ParseTreeType<'t>, + _with_generic_parameter_item: &ParseTreeType<'t>, + _with_generic_parameter_list_list: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let mut with_generic_parameter_list_list = pop_item!( + self, + with_generic_parameter_list_list, + WithGenericParameterListList, + context + ); + let with_generic_parameter_item = pop_item!( + self, + with_generic_parameter_item, + WithGenericParameterItem, + context + ); + let comma = pop_item!(self, comma, Comma, context); + let with_generic_parameter_list_list_0_built = WithGenericParameterListList { + with_generic_parameter_item: Box::new(with_generic_parameter_item), + comma: Box::new(comma), + }; + // Add an element to the vector + with_generic_parameter_list_list.push(with_generic_parameter_list_list_0_built); + self.push( + ASTType::WithGenericParameterListList(with_generic_parameter_list_list), + context, + ); + Ok(()) + } + + /// Semantic action for production 707: + /// + /// `WithGenericParameterListList /* Vec::New */: ;` + /// + #[parol_runtime::function_name::named] + fn with_generic_parameter_list_list_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_generic_parameter_list_list_1_built = Vec::new(); + self.push( + ASTType::WithGenericParameterListList(with_generic_parameter_list_list_1_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 708: + /// + /// `WithGenericParameterListOpt /* Option::Some */: Comma;` + /// + #[parol_runtime::function_name::named] + fn with_generic_parameter_list_opt_0(&mut self, _comma: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let comma = pop_item!(self, comma, Comma, context); + let with_generic_parameter_list_opt_0_built = WithGenericParameterListOpt { + comma: Box::new(comma), + }; + self.push( + ASTType::WithGenericParameterListOpt(Some(with_generic_parameter_list_opt_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 709: + /// + /// `WithGenericParameterListOpt /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn with_generic_parameter_list_opt_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::WithGenericParameterListOpt(None), context); + Ok(()) + } + + /// Semantic action for production 710: + /// + /// `WithGenericParameterItem: Identifier;` + /// + #[parol_runtime::function_name::named] + fn with_generic_parameter_item(&mut self, _identifier: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let identifier = pop_item!(self, identifier, Identifier, context); + let with_generic_parameter_item_built = WithGenericParameterItem { + identifier: Box::new(identifier), + }; + // Calling user action here + self.user_grammar + .with_generic_parameter_item(&with_generic_parameter_item_built)?; + self.push( + ASTType::WithGenericParameterItem(with_generic_parameter_item_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 711: + /// + /// `WithGenericArgument: ColonColonLAngle %push(Generic) WithGenericArgumentList RAngle %pop();` + /// + #[parol_runtime::function_name::named] + fn with_generic_argument( + &mut self, + _colon_colon_l_angle: &ParseTreeType<'t>, + _with_generic_argument_list: &ParseTreeType<'t>, + _r_angle: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let r_angle = pop_item!(self, r_angle, RAngle, context); + let with_generic_argument_list = pop_item!( + self, + with_generic_argument_list, + WithGenericArgumentList, + context + ); + let colon_colon_l_angle = pop_item!(self, colon_colon_l_angle, ColonColonLAngle, context); + let with_generic_argument_built = WithGenericArgument { + colon_colon_l_angle: Box::new(colon_colon_l_angle), + with_generic_argument_list: Box::new(with_generic_argument_list), + r_angle: Box::new(r_angle), + }; + // Calling user action here + self.user_grammar + .with_generic_argument(&with_generic_argument_built)?; + self.push( + ASTType::WithGenericArgument(with_generic_argument_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 712: + /// + /// `WithGenericArgumentList: WithGenericArgumentItem WithGenericArgumentListList /* Vec */ WithGenericArgumentListOpt /* Option */;` + /// + #[parol_runtime::function_name::named] + fn with_generic_argument_list( + &mut self, + _with_generic_argument_item: &ParseTreeType<'t>, + _with_generic_argument_list_list: &ParseTreeType<'t>, + _with_generic_argument_list_opt: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_generic_argument_list_opt = pop_item!( + self, + with_generic_argument_list_opt, + WithGenericArgumentListOpt, + context + ); + let with_generic_argument_list_list = pop_and_reverse_item!( + self, + with_generic_argument_list_list, + WithGenericArgumentListList, + context + ); + let with_generic_argument_item = pop_item!( + self, + with_generic_argument_item, + WithGenericArgumentItem, + context + ); + let with_generic_argument_list_built = WithGenericArgumentList { + with_generic_argument_item: Box::new(with_generic_argument_item), + with_generic_argument_list_list, + with_generic_argument_list_opt, + }; + // Calling user action here + self.user_grammar + .with_generic_argument_list(&with_generic_argument_list_built)?; + self.push( + ASTType::WithGenericArgumentList(with_generic_argument_list_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 713: + /// + /// `WithGenericArgumentListList /* Vec::Push */: Comma WithGenericArgumentItem WithGenericArgumentListList;` + /// + #[parol_runtime::function_name::named] + fn with_generic_argument_list_list_0( + &mut self, + _comma: &ParseTreeType<'t>, + _with_generic_argument_item: &ParseTreeType<'t>, + _with_generic_argument_list_list: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let mut with_generic_argument_list_list = pop_item!( + self, + with_generic_argument_list_list, + WithGenericArgumentListList, + context + ); + let with_generic_argument_item = pop_item!( + self, + with_generic_argument_item, + WithGenericArgumentItem, + context + ); + let comma = pop_item!(self, comma, Comma, context); + let with_generic_argument_list_list_0_built = WithGenericArgumentListList { + with_generic_argument_item: Box::new(with_generic_argument_item), + comma: Box::new(comma), + }; + // Add an element to the vector + with_generic_argument_list_list.push(with_generic_argument_list_list_0_built); + self.push( + ASTType::WithGenericArgumentListList(with_generic_argument_list_list), + context, + ); + Ok(()) + } + + /// Semantic action for production 714: + /// + /// `WithGenericArgumentListList /* Vec::New */: ;` + /// + #[parol_runtime::function_name::named] + fn with_generic_argument_list_list_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_generic_argument_list_list_1_built = Vec::new(); + self.push( + ASTType::WithGenericArgumentListList(with_generic_argument_list_list_1_built), + context, + ); + Ok(()) + } + + /// Semantic action for production 715: + /// + /// `WithGenericArgumentListOpt /* Option::Some */: Comma;` + /// + #[parol_runtime::function_name::named] + fn with_generic_argument_list_opt_0(&mut self, _comma: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let comma = pop_item!(self, comma, Comma, context); + let with_generic_argument_list_opt_0_built = WithGenericArgumentListOpt { + comma: Box::new(comma), + }; self.push( - ASTType::WithParameterItemGroup0(with_parameter_item_group0_1_built), + ASTType::WithGenericArgumentListOpt(Some(with_generic_argument_list_opt_0_built)), context, ); Ok(()) } - /// Semantic action for production 693: + /// Semantic action for production 716: /// - /// `WithParameterItemGroup: Param;` + /// `WithGenericArgumentListOpt /* Option::None */: ;` /// #[parol_runtime::function_name::named] - fn with_parameter_item_group_0(&mut self, _param: &ParseTreeType<'t>) -> Result<()> { + fn with_generic_argument_list_opt_1(&mut self) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); - let param = pop_item!(self, param, Param, context); - let with_parameter_item_group_0_built = WithParameterItemGroupParam { - param: Box::new(param), + self.push(ASTType::WithGenericArgumentListOpt(None), context); + Ok(()) + } + + /// Semantic action for production 717: + /// + /// `WithGenericArgumentItem: ScopedIdentifier;` + /// + #[parol_runtime::function_name::named] + fn with_generic_argument_item_0( + &mut self, + _scoped_identifier: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let scoped_identifier = pop_item!(self, scoped_identifier, ScopedIdentifier, context); + let with_generic_argument_item_0_built = WithGenericArgumentItemScopedIdentifier { + scoped_identifier: Box::new(scoped_identifier), }; - let with_parameter_item_group_0_built = - WithParameterItemGroup::Param(with_parameter_item_group_0_built); + let with_generic_argument_item_0_built = + WithGenericArgumentItem::ScopedIdentifier(with_generic_argument_item_0_built); + // Calling user action here + self.user_grammar + .with_generic_argument_item(&with_generic_argument_item_0_built)?; self.push( - ASTType::WithParameterItemGroup(with_parameter_item_group_0_built), + ASTType::WithGenericArgumentItem(with_generic_argument_item_0_built), context, ); Ok(()) } - /// Semantic action for production 694: + /// Semantic action for production 718: /// - /// `WithParameterItemGroup: Local;` + /// `WithGenericArgumentItem: Number;` /// #[parol_runtime::function_name::named] - fn with_parameter_item_group_1(&mut self, _local: &ParseTreeType<'t>) -> Result<()> { + fn with_generic_argument_item_1(&mut self, _number: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); - let local = pop_item!(self, local, Local, context); - let with_parameter_item_group_1_built = WithParameterItemGroupLocal { - local: Box::new(local), + let number = pop_item!(self, number, Number, context); + let with_generic_argument_item_1_built = WithGenericArgumentItemNumber { + number: Box::new(number), }; - let with_parameter_item_group_1_built = - WithParameterItemGroup::Local(with_parameter_item_group_1_built); + let with_generic_argument_item_1_built = + WithGenericArgumentItem::Number(with_generic_argument_item_1_built); + // Calling user action here + self.user_grammar + .with_generic_argument_item(&with_generic_argument_item_1_built)?; self.push( - ASTType::WithParameterItemGroup(with_parameter_item_group_1_built), + ASTType::WithGenericArgumentItem(with_generic_argument_item_1_built), context, ); Ok(()) } - /// Semantic action for production 695: + /// Semantic action for production 719: /// /// `PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen;` /// @@ -27539,7 +28474,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 696: + /// Semantic action for production 720: /// /// `PortDeclarationOpt /* Option::Some */: PortDeclarationList;` /// @@ -27559,7 +28494,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 697: + /// Semantic action for production 721: /// /// `PortDeclarationOpt /* Option::None */: ;` /// @@ -27571,7 +28506,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 698: + /// Semantic action for production 722: /// /// `PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */;` /// @@ -27613,7 +28548,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 699: + /// Semantic action for production 723: /// /// `PortDeclarationListList /* Vec::Push */: Comma PortDeclarationGroup PortDeclarationListList;` /// @@ -27648,7 +28583,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 700: + /// Semantic action for production 724: /// /// `PortDeclarationListList /* Vec::New */: ;` /// @@ -27664,7 +28599,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 701: + /// Semantic action for production 725: /// /// `PortDeclarationListOpt /* Option::Some */: Comma;` /// @@ -27683,7 +28618,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 702: + /// Semantic action for production 726: /// /// `PortDeclarationListOpt /* Option::None */: ;` /// @@ -27695,7 +28630,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 703: + /// Semantic action for production 727: /// /// `PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup;` /// @@ -27733,7 +28668,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 704: + /// Semantic action for production 728: /// /// `PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace;` /// @@ -27767,7 +28702,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 705: + /// Semantic action for production 729: /// /// `PortDeclarationGroupGroup: PortDeclarationItem;` /// @@ -27792,7 +28727,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 706: + /// Semantic action for production 730: /// /// `PortDeclarationGroupList /* Vec::Push */: Attribute PortDeclarationGroupList;` /// @@ -27823,7 +28758,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 707: + /// Semantic action for production 731: /// /// `PortDeclarationGroupList /* Vec::New */: ;` /// @@ -27839,7 +28774,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 708: + /// Semantic action for production 732: /// /// `PortDeclarationItem: Identifier Colon PortDeclarationItemGroup;` /// @@ -27875,7 +28810,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 709: + /// Semantic action for production 733: /// /// `PortDeclarationItemGroup: Direction ArrayType;` /// @@ -27902,7 +28837,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 710: + /// Semantic action for production 734: /// /// `PortDeclarationItemGroup: Interface PortDeclarationItemOpt /* Option */;` /// @@ -27937,7 +28872,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 711: + /// Semantic action for production 735: /// /// `PortDeclarationItemOpt /* Option::Some */: Array;` /// @@ -27956,7 +28891,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 712: + /// Semantic action for production 736: /// /// `PortDeclarationItemOpt /* Option::None */: ;` /// @@ -27968,7 +28903,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 713: + /// Semantic action for production 737: /// /// `Direction: Input;` /// @@ -27987,7 +28922,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 714: + /// Semantic action for production 738: /// /// `Direction: Output;` /// @@ -28006,7 +28941,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 715: + /// Semantic action for production 739: /// /// `Direction: Inout;` /// @@ -28025,7 +28960,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 716: + /// Semantic action for production 740: /// /// `Direction: Ref;` /// @@ -28044,7 +28979,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 717: + /// Semantic action for production 741: /// /// `Direction: Modport;` /// @@ -28063,9 +28998,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 718: + /// Semantic action for production 742: /// - /// `FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace;` + /// `FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ FunctionDeclarationOpt1 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace;` /// #[parol_runtime::function_name::named] fn function_declaration( @@ -28074,6 +29009,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { _identifier: &ParseTreeType<'t>, _function_declaration_opt: &ParseTreeType<'t>, _function_declaration_opt0: &ParseTreeType<'t>, + _function_declaration_opt1: &ParseTreeType<'t>, _l_brace: &ParseTreeType<'t>, _function_declaration_list: &ParseTreeType<'t>, _r_brace: &ParseTreeType<'t>, @@ -28088,6 +29024,12 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { context ); let l_brace = pop_item!(self, l_brace, LBrace, context); + let function_declaration_opt1 = pop_item!( + self, + function_declaration_opt1, + FunctionDeclarationOpt1, + context + ); let function_declaration_opt0 = pop_item!( self, function_declaration_opt0, @@ -28107,6 +29049,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { identifier: Box::new(identifier), function_declaration_opt, function_declaration_opt0, + function_declaration_opt1, l_brace: Box::new(l_brace), function_declaration_list, r_brace: Box::new(r_brace), @@ -28121,7 +29064,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 719: + /// Semantic action for production 743: /// /// `FunctionDeclarationList /* Vec::Push */: FunctionItem FunctionDeclarationList;` /// @@ -28152,7 +29095,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 720: + /// Semantic action for production 744: /// /// `FunctionDeclarationList /* Vec::New */: ;` /// @@ -28168,12 +29111,12 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 721: + /// Semantic action for production 745: /// - /// `FunctionDeclarationOpt0 /* Option::Some */: MinusGT ScalarType;` + /// `FunctionDeclarationOpt1 /* Option::Some */: MinusGT ScalarType;` /// #[parol_runtime::function_name::named] - fn function_declaration_opt0_0( + fn function_declaration_opt1_0( &mut self, _minus_g_t: &ParseTreeType<'t>, _scalar_type: &ParseTreeType<'t>, @@ -28182,10 +29125,41 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { trace!("{}", self.trace_item_stack(context)); let scalar_type = pop_item!(self, scalar_type, ScalarType, context); let minus_g_t = pop_item!(self, minus_g_t, MinusGT, context); - let function_declaration_opt0_0_built = FunctionDeclarationOpt0 { + let function_declaration_opt1_0_built = FunctionDeclarationOpt1 { minus_g_t: Box::new(minus_g_t), scalar_type: Box::new(scalar_type), }; + self.push( + ASTType::FunctionDeclarationOpt1(Some(function_declaration_opt1_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 746: + /// + /// `FunctionDeclarationOpt1 /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn function_declaration_opt1_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::FunctionDeclarationOpt1(None), context); + Ok(()) + } + + /// Semantic action for production 747: + /// + /// `FunctionDeclarationOpt0 /* Option::Some */: PortDeclaration;` + /// + #[parol_runtime::function_name::named] + fn function_declaration_opt0_0(&mut self, _port_declaration: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let port_declaration = pop_item!(self, port_declaration, PortDeclaration, context); + let function_declaration_opt0_0_built = FunctionDeclarationOpt0 { + port_declaration: Box::new(port_declaration), + }; self.push( ASTType::FunctionDeclarationOpt0(Some(function_declaration_opt0_0_built)), context, @@ -28193,7 +29167,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 722: + /// Semantic action for production 748: /// /// `FunctionDeclarationOpt0 /* Option::None */: ;` /// @@ -28205,17 +29179,21 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 723: + /// Semantic action for production 749: /// - /// `FunctionDeclarationOpt /* Option::Some */: PortDeclaration;` + /// `FunctionDeclarationOpt /* Option::Some */: WithGenericParameter;` /// #[parol_runtime::function_name::named] - fn function_declaration_opt_0(&mut self, _port_declaration: &ParseTreeType<'t>) -> Result<()> { + fn function_declaration_opt_0( + &mut self, + _with_generic_parameter: &ParseTreeType<'t>, + ) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); - let port_declaration = pop_item!(self, port_declaration, PortDeclaration, context); + let with_generic_parameter = + pop_item!(self, with_generic_parameter, WithGenericParameter, context); let function_declaration_opt_0_built = FunctionDeclarationOpt { - port_declaration: Box::new(port_declaration), + with_generic_parameter: Box::new(with_generic_parameter), }; self.push( ASTType::FunctionDeclarationOpt(Some(function_declaration_opt_0_built)), @@ -28224,7 +29202,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 724: + /// Semantic action for production 750: /// /// `FunctionDeclarationOpt /* Option::None */: ;` /// @@ -28236,7 +29214,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 725: + /// Semantic action for production 751: /// /// `FunctionItem: VarDeclaration;` /// @@ -28255,7 +29233,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 726: + /// Semantic action for production 752: /// /// `FunctionItem: Statement;` /// @@ -28274,7 +29252,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 727: + /// Semantic action for production 753: /// /// `ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon;` /// @@ -28309,7 +29287,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 728: + /// Semantic action for production 754: /// /// `ImportDeclarationOpt /* Option::Some */: ColonColon Star;` /// @@ -28334,7 +29312,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 729: + /// Semantic action for production 755: /// /// `ImportDeclarationOpt /* Option::None */: ;` /// @@ -28346,7 +29324,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 730: + /// Semantic action for production 756: /// /// `ExportDeclaration: Export ExportDeclarationGroup Semicolon;` /// @@ -28382,7 +29360,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 731: + /// Semantic action for production 757: /// /// `ExportDeclarationGroup: Star;` /// @@ -28403,7 +29381,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 732: + /// Semantic action for production 758: /// /// `ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */;` /// @@ -28434,7 +29412,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 733: + /// Semantic action for production 759: /// /// `ExportDeclarationOpt /* Option::Some */: ColonColon Star;` /// @@ -28459,7 +29437,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 734: + /// Semantic action for production 760: /// /// `ExportDeclarationOpt /* Option::None */: ;` /// @@ -28471,9 +29449,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 735: + /// Semantic action for production 761: /// - /// `ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace;` + /// `ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ ModuleDeclarationOpt2 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace;` /// #[parol_runtime::function_name::named] fn module_declaration( @@ -28483,6 +29461,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { _identifier: &ParseTreeType<'t>, _module_declaration_opt0: &ParseTreeType<'t>, _module_declaration_opt1: &ParseTreeType<'t>, + _module_declaration_opt2: &ParseTreeType<'t>, _l_brace: &ParseTreeType<'t>, _module_declaration_list: &ParseTreeType<'t>, _r_brace: &ParseTreeType<'t>, @@ -28497,6 +29476,12 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { context ); let l_brace = pop_item!(self, l_brace, LBrace, context); + let module_declaration_opt2 = pop_item!( + self, + module_declaration_opt2, + ModuleDeclarationOpt2, + context + ); let module_declaration_opt1 = pop_item!( self, module_declaration_opt1, @@ -28519,6 +29504,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { identifier: Box::new(identifier), module_declaration_opt0, module_declaration_opt1, + module_declaration_opt2, l_brace: Box::new(l_brace), module_declaration_list, r_brace: Box::new(r_brace), @@ -28533,7 +29519,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 736: + /// Semantic action for production 762: /// /// `ModuleDeclarationList /* Vec::Push */: ModuleGroup ModuleDeclarationList;` /// @@ -28564,7 +29550,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 737: + /// Semantic action for production 763: /// /// `ModuleDeclarationList /* Vec::New */: ;` /// @@ -28580,18 +29566,49 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 738: + /// Semantic action for production 764: /// - /// `ModuleDeclarationOpt1 /* Option::Some */: PortDeclaration;` + /// `ModuleDeclarationOpt2 /* Option::Some */: PortDeclaration;` /// #[parol_runtime::function_name::named] - fn module_declaration_opt1_0(&mut self, _port_declaration: &ParseTreeType<'t>) -> Result<()> { + fn module_declaration_opt2_0(&mut self, _port_declaration: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let port_declaration = pop_item!(self, port_declaration, PortDeclaration, context); - let module_declaration_opt1_0_built = ModuleDeclarationOpt1 { + let module_declaration_opt2_0_built = ModuleDeclarationOpt2 { port_declaration: Box::new(port_declaration), }; + self.push( + ASTType::ModuleDeclarationOpt2(Some(module_declaration_opt2_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 765: + /// + /// `ModuleDeclarationOpt2 /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn module_declaration_opt2_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::ModuleDeclarationOpt2(None), context); + Ok(()) + } + + /// Semantic action for production 766: + /// + /// `ModuleDeclarationOpt1 /* Option::Some */: WithParameter;` + /// + #[parol_runtime::function_name::named] + fn module_declaration_opt1_0(&mut self, _with_parameter: &ParseTreeType<'t>) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_parameter = pop_item!(self, with_parameter, WithParameter, context); + let module_declaration_opt1_0_built = ModuleDeclarationOpt1 { + with_parameter: Box::new(with_parameter), + }; self.push( ASTType::ModuleDeclarationOpt1(Some(module_declaration_opt1_0_built)), context, @@ -28599,7 +29616,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 739: + /// Semantic action for production 767: /// /// `ModuleDeclarationOpt1 /* Option::None */: ;` /// @@ -28611,17 +29628,21 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 740: + /// Semantic action for production 768: /// - /// `ModuleDeclarationOpt0 /* Option::Some */: WithParameter;` + /// `ModuleDeclarationOpt0 /* Option::Some */: WithGenericParameter;` /// #[parol_runtime::function_name::named] - fn module_declaration_opt0_0(&mut self, _with_parameter: &ParseTreeType<'t>) -> Result<()> { + fn module_declaration_opt0_0( + &mut self, + _with_generic_parameter: &ParseTreeType<'t>, + ) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); - let with_parameter = pop_item!(self, with_parameter, WithParameter, context); + let with_generic_parameter = + pop_item!(self, with_generic_parameter, WithGenericParameter, context); let module_declaration_opt0_0_built = ModuleDeclarationOpt0 { - with_parameter: Box::new(with_parameter), + with_generic_parameter: Box::new(with_generic_parameter), }; self.push( ASTType::ModuleDeclarationOpt0(Some(module_declaration_opt0_0_built)), @@ -28630,7 +29651,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 741: + /// Semantic action for production 769: /// /// `ModuleDeclarationOpt0 /* Option::None */: ;` /// @@ -28642,7 +29663,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 742: + /// Semantic action for production 770: /// /// `ModuleDeclarationOpt /* Option::Some */: Pub;` /// @@ -28661,7 +29682,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 743: + /// Semantic action for production 771: /// /// `ModuleDeclarationOpt /* Option::None */: ;` /// @@ -28673,7 +29694,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 744: + /// Semantic action for production 772: /// /// `ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */;` /// @@ -28720,7 +29741,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 745: + /// Semantic action for production 773: /// /// `ModuleIfDeclarationList /* Vec::Push */: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList;` /// @@ -28765,7 +29786,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 746: + /// Semantic action for production 774: /// /// `ModuleIfDeclarationList /* Vec::New */: ;` /// @@ -28781,7 +29802,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 747: + /// Semantic action for production 775: /// /// `ModuleIfDeclarationOpt /* Option::Some */: Else ModuleOptionalNamedBlock;` /// @@ -28811,7 +29832,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 748: + /// Semantic action for production 776: /// /// `ModuleIfDeclarationOpt /* Option::None */: ;` /// @@ -28823,7 +29844,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 749: + /// Semantic action for production 777: /// /// `ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock;` /// @@ -28868,7 +29889,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 750: + /// Semantic action for production 778: /// /// `ModuleForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression;` /// @@ -28896,7 +29917,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 751: + /// Semantic action for production 779: /// /// `ModuleForDeclarationOpt /* Option::None */: ;` /// @@ -28908,7 +29929,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 752: + /// Semantic action for production 780: /// /// `ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace;` /// @@ -28943,7 +29964,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 753: + /// Semantic action for production 781: /// /// `ModuleNamedBlockList /* Vec::Push */: ModuleGroup ModuleNamedBlockList;` /// @@ -28970,7 +29991,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 754: + /// Semantic action for production 782: /// /// `ModuleNamedBlockList /* Vec::New */: ;` /// @@ -28986,7 +30007,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 755: + /// Semantic action for production 783: /// /// `ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace;` /// @@ -29030,7 +30051,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 756: + /// Semantic action for production 784: /// /// `ModuleOptionalNamedBlockList /* Vec::Push */: ModuleGroup ModuleOptionalNamedBlockList;` /// @@ -29061,7 +30082,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 757: + /// Semantic action for production 785: /// /// `ModuleOptionalNamedBlockList /* Vec::New */: ;` /// @@ -29077,7 +30098,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 758: + /// Semantic action for production 786: /// /// `ModuleOptionalNamedBlockOpt /* Option::Some */: Colon Identifier;` /// @@ -29102,7 +30123,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 759: + /// Semantic action for production 787: /// /// `ModuleOptionalNamedBlockOpt /* Option::None */: ;` /// @@ -29114,7 +30135,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 760: + /// Semantic action for production 788: /// /// `ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup;` /// @@ -29139,7 +30160,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 761: + /// Semantic action for production 789: /// /// `ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace;` /// @@ -29170,7 +30191,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 762: + /// Semantic action for production 790: /// /// `ModuleGroupGroupList /* Vec::Push */: ModuleGroup ModuleGroupGroupList;` /// @@ -29197,7 +30218,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 763: + /// Semantic action for production 791: /// /// `ModuleGroupGroupList /* Vec::New */: ;` /// @@ -29213,7 +30234,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 764: + /// Semantic action for production 792: /// /// `ModuleGroupGroup: ModuleItem;` /// @@ -29233,7 +30254,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 765: + /// Semantic action for production 793: /// /// `ModuleGroupList /* Vec::Push */: Attribute ModuleGroupList;` /// @@ -29256,7 +30277,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 766: + /// Semantic action for production 794: /// /// `ModuleGroupList /* Vec::New */: ;` /// @@ -29269,7 +30290,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 767: + /// Semantic action for production 795: /// /// `ModuleItem: LetDeclaration;` /// @@ -29288,7 +30309,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 768: + /// Semantic action for production 796: /// /// `ModuleItem: VarDeclaration;` /// @@ -29307,7 +30328,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 769: + /// Semantic action for production 797: /// /// `ModuleItem: InstDeclaration;` /// @@ -29326,7 +30347,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 770: + /// Semantic action for production 798: /// /// `ModuleItem: TypeDefDeclaration;` /// @@ -29346,7 +30367,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 771: + /// Semantic action for production 799: /// /// `ModuleItem: LocalDeclaration;` /// @@ -29365,7 +30386,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 772: + /// Semantic action for production 800: /// /// `ModuleItem: AlwaysFfDeclaration;` /// @@ -29385,7 +30406,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 773: + /// Semantic action for production 801: /// /// `ModuleItem: AlwaysCombDeclaration;` /// @@ -29409,7 +30430,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 774: + /// Semantic action for production 802: /// /// `ModuleItem: AssignDeclaration;` /// @@ -29428,7 +30449,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 775: + /// Semantic action for production 803: /// /// `ModuleItem: FunctionDeclaration;` /// @@ -29448,7 +30469,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 776: + /// Semantic action for production 804: /// /// `ModuleItem: ModuleIfDeclaration;` /// @@ -29468,7 +30489,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 777: + /// Semantic action for production 805: /// /// `ModuleItem: ModuleForDeclaration;` /// @@ -29488,7 +30509,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 778: + /// Semantic action for production 806: /// /// `ModuleItem: EnumDeclaration;` /// @@ -29507,7 +30528,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 779: + /// Semantic action for production 807: /// /// `ModuleItem: StructUnionDeclaration;` /// @@ -29531,7 +30552,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 780: + /// Semantic action for production 808: /// /// `ModuleItem: ModuleNamedBlock;` /// @@ -29550,7 +30571,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 781: + /// Semantic action for production 809: /// /// `ModuleItem: ImportDeclaration;` /// @@ -29569,7 +30590,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 782: + /// Semantic action for production 810: /// /// `ModuleItem: InitialDeclaration;` /// @@ -29588,7 +30609,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 783: + /// Semantic action for production 811: /// /// `ModuleItem: FinalDeclaration;` /// @@ -29607,9 +30628,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 784: + /// Semantic action for production 812: /// - /// `InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace;` + /// `InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ InterfaceDeclarationOpt1 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace;` /// #[parol_runtime::function_name::named] fn interface_declaration( @@ -29618,6 +30639,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { _interface: &ParseTreeType<'t>, _identifier: &ParseTreeType<'t>, _interface_declaration_opt0: &ParseTreeType<'t>, + _interface_declaration_opt1: &ParseTreeType<'t>, _l_brace: &ParseTreeType<'t>, _interface_declaration_list: &ParseTreeType<'t>, _r_brace: &ParseTreeType<'t>, @@ -29632,6 +30654,12 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { context ); let l_brace = pop_item!(self, l_brace, LBrace, context); + let interface_declaration_opt1 = pop_item!( + self, + interface_declaration_opt1, + InterfaceDeclarationOpt1, + context + ); let interface_declaration_opt0 = pop_item!( self, interface_declaration_opt0, @@ -29651,6 +30679,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { interface: Box::new(interface), identifier: Box::new(identifier), interface_declaration_opt0, + interface_declaration_opt1, l_brace: Box::new(l_brace), interface_declaration_list, r_brace: Box::new(r_brace), @@ -29665,7 +30694,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 785: + /// Semantic action for production 813: /// /// `InterfaceDeclarationList /* Vec::Push */: InterfaceGroup InterfaceDeclarationList;` /// @@ -29696,7 +30725,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 786: + /// Semantic action for production 814: /// /// `InterfaceDeclarationList /* Vec::New */: ;` /// @@ -29712,18 +30741,53 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 787: + /// Semantic action for production 815: /// - /// `InterfaceDeclarationOpt0 /* Option::Some */: WithParameter;` + /// `InterfaceDeclarationOpt1 /* Option::Some */: WithParameter;` /// #[parol_runtime::function_name::named] - fn interface_declaration_opt0_0(&mut self, _with_parameter: &ParseTreeType<'t>) -> Result<()> { + fn interface_declaration_opt1_0(&mut self, _with_parameter: &ParseTreeType<'t>) -> Result<()> { let context = function_name!(); trace!("{}", self.trace_item_stack(context)); let with_parameter = pop_item!(self, with_parameter, WithParameter, context); - let interface_declaration_opt0_0_built = InterfaceDeclarationOpt0 { + let interface_declaration_opt1_0_built = InterfaceDeclarationOpt1 { with_parameter: Box::new(with_parameter), }; + self.push( + ASTType::InterfaceDeclarationOpt1(Some(interface_declaration_opt1_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 816: + /// + /// `InterfaceDeclarationOpt1 /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn interface_declaration_opt1_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::InterfaceDeclarationOpt1(None), context); + Ok(()) + } + + /// Semantic action for production 817: + /// + /// `InterfaceDeclarationOpt0 /* Option::Some */: WithGenericParameter;` + /// + #[parol_runtime::function_name::named] + fn interface_declaration_opt0_0( + &mut self, + _with_generic_parameter: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_generic_parameter = + pop_item!(self, with_generic_parameter, WithGenericParameter, context); + let interface_declaration_opt0_0_built = InterfaceDeclarationOpt0 { + with_generic_parameter: Box::new(with_generic_parameter), + }; self.push( ASTType::InterfaceDeclarationOpt0(Some(interface_declaration_opt0_0_built)), context, @@ -29731,7 +30795,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 788: + /// Semantic action for production 818: /// /// `InterfaceDeclarationOpt0 /* Option::None */: ;` /// @@ -29743,7 +30807,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 789: + /// Semantic action for production 819: /// /// `InterfaceDeclarationOpt /* Option::Some */: Pub;` /// @@ -29762,7 +30826,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 790: + /// Semantic action for production 820: /// /// `InterfaceDeclarationOpt /* Option::None */: ;` /// @@ -29774,7 +30838,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 791: + /// Semantic action for production 821: /// /// `InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */;` /// @@ -29822,7 +30886,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 792: + /// Semantic action for production 822: /// /// `InterfaceIfDeclarationList /* Vec::Push */: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList;` /// @@ -29867,7 +30931,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 793: + /// Semantic action for production 823: /// /// `InterfaceIfDeclarationList /* Vec::New */: ;` /// @@ -29883,7 +30947,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 794: + /// Semantic action for production 824: /// /// `InterfaceIfDeclarationOpt /* Option::Some */: Else InterfaceOptionalNamedBlock;` /// @@ -29913,7 +30977,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 795: + /// Semantic action for production 825: /// /// `InterfaceIfDeclarationOpt /* Option::None */: ;` /// @@ -29925,7 +30989,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 796: + /// Semantic action for production 826: /// /// `InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock;` /// @@ -29971,7 +31035,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 797: + /// Semantic action for production 827: /// /// `InterfaceForDeclarationOpt /* Option::Some */: Step AssignmentOperator Expression;` /// @@ -29999,7 +31063,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 798: + /// Semantic action for production 828: /// /// `InterfaceForDeclarationOpt /* Option::None */: ;` /// @@ -30011,7 +31075,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 799: + /// Semantic action for production 829: /// /// `InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace;` /// @@ -30053,7 +31117,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 800: + /// Semantic action for production 830: /// /// `InterfaceNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceNamedBlockList;` /// @@ -30084,7 +31148,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 801: + /// Semantic action for production 831: /// /// `InterfaceNamedBlockList /* Vec::New */: ;` /// @@ -30100,7 +31164,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 802: + /// Semantic action for production 832: /// /// `InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace;` /// @@ -30144,7 +31208,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 803: + /// Semantic action for production 833: /// /// `InterfaceOptionalNamedBlockList /* Vec::Push */: InterfaceGroup InterfaceOptionalNamedBlockList;` /// @@ -30175,7 +31239,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 804: + /// Semantic action for production 834: /// /// `InterfaceOptionalNamedBlockList /* Vec::New */: ;` /// @@ -30191,7 +31255,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 805: + /// Semantic action for production 835: /// /// `InterfaceOptionalNamedBlockOpt /* Option::Some */: Colon Identifier;` /// @@ -30218,7 +31282,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 806: + /// Semantic action for production 836: /// /// `InterfaceOptionalNamedBlockOpt /* Option::None */: ;` /// @@ -30230,7 +31294,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 807: + /// Semantic action for production 837: /// /// `InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup;` /// @@ -30256,7 +31320,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 808: + /// Semantic action for production 838: /// /// `InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace;` /// @@ -30292,7 +31356,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 809: + /// Semantic action for production 839: /// /// `InterfaceGroupGroupList /* Vec::Push */: InterfaceGroup InterfaceGroupGroupList;` /// @@ -30323,7 +31387,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 810: + /// Semantic action for production 840: /// /// `InterfaceGroupGroupList /* Vec::New */: ;` /// @@ -30339,7 +31403,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 811: + /// Semantic action for production 841: /// /// `InterfaceGroupGroup: InterfaceItem;` /// @@ -30360,7 +31424,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 812: + /// Semantic action for production 842: /// /// `InterfaceGroupList /* Vec::Push */: Attribute InterfaceGroupList;` /// @@ -30384,7 +31448,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 813: + /// Semantic action for production 843: /// /// `InterfaceGroupList /* Vec::New */: ;` /// @@ -30400,7 +31464,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 814: + /// Semantic action for production 844: /// /// `InterfaceItem: LetDeclaration;` /// @@ -30419,7 +31483,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 815: + /// Semantic action for production 845: /// /// `InterfaceItem: VarDeclaration;` /// @@ -30438,7 +31502,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 816: + /// Semantic action for production 846: /// /// `InterfaceItem: LocalDeclaration;` /// @@ -30457,7 +31521,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 817: + /// Semantic action for production 847: /// /// `InterfaceItem: ModportDeclaration;` /// @@ -30476,7 +31540,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 818: + /// Semantic action for production 848: /// /// `InterfaceItem: InterfaceIfDeclaration;` /// @@ -30500,7 +31564,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 819: + /// Semantic action for production 849: /// /// `InterfaceItem: InterfaceForDeclaration;` /// @@ -30524,7 +31588,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 820: + /// Semantic action for production 850: /// /// `InterfaceItem: TypeDefDeclaration;` /// @@ -30544,7 +31608,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 821: + /// Semantic action for production 851: /// /// `InterfaceItem: EnumDeclaration;` /// @@ -30563,7 +31627,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 822: + /// Semantic action for production 852: /// /// `InterfaceItem: StructUnionDeclaration;` /// @@ -30587,7 +31651,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 823: + /// Semantic action for production 853: /// /// `InterfaceItem: InterfaceNamedBlock;` /// @@ -30607,7 +31671,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 824: + /// Semantic action for production 854: /// /// `InterfaceItem: FunctionDeclaration;` /// @@ -30627,7 +31691,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 825: + /// Semantic action for production 855: /// /// `InterfaceItem: ImportDeclaration;` /// @@ -30646,7 +31710,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 826: + /// Semantic action for production 856: /// /// `InterfaceItem: InitialDeclaration;` /// @@ -30665,7 +31729,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 827: + /// Semantic action for production 857: /// /// `InterfaceItem: FinalDeclaration;` /// @@ -30684,9 +31748,9 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 828: + /// Semantic action for production 858: /// - /// `PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier LBrace PackageDeclarationList /* Vec */ RBrace;` + /// `PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier PackageDeclarationOpt0 /* Option */ LBrace PackageDeclarationList /* Vec */ RBrace;` /// #[parol_runtime::function_name::named] fn package_declaration( @@ -30694,6 +31758,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { _package_declaration_opt: &ParseTreeType<'t>, _package: &ParseTreeType<'t>, _identifier: &ParseTreeType<'t>, + _package_declaration_opt0: &ParseTreeType<'t>, _l_brace: &ParseTreeType<'t>, _package_declaration_list: &ParseTreeType<'t>, _r_brace: &ParseTreeType<'t>, @@ -30708,6 +31773,12 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { context ); let l_brace = pop_item!(self, l_brace, LBrace, context); + let package_declaration_opt0 = pop_item!( + self, + package_declaration_opt0, + PackageDeclarationOpt0, + context + ); let identifier = pop_item!(self, identifier, Identifier, context); let package = pop_item!(self, package, Package, context); let package_declaration_opt = pop_item!( @@ -30720,6 +31791,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { package_declaration_opt, package: Box::new(package), identifier: Box::new(identifier), + package_declaration_opt0, l_brace: Box::new(l_brace), package_declaration_list, r_brace: Box::new(r_brace), @@ -30734,7 +31806,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 829: + /// Semantic action for production 859: /// /// `PackageDeclarationList /* Vec::Push */: PackageGroup PackageDeclarationList;` /// @@ -30765,7 +31837,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 830: + /// Semantic action for production 860: /// /// `PackageDeclarationList /* Vec::New */: ;` /// @@ -30781,7 +31853,42 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 831: + /// Semantic action for production 861: + /// + /// `PackageDeclarationOpt0 /* Option::Some */: WithGenericParameter;` + /// + #[parol_runtime::function_name::named] + fn package_declaration_opt0_0( + &mut self, + _with_generic_parameter: &ParseTreeType<'t>, + ) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + let with_generic_parameter = + pop_item!(self, with_generic_parameter, WithGenericParameter, context); + let package_declaration_opt0_0_built = PackageDeclarationOpt0 { + with_generic_parameter: Box::new(with_generic_parameter), + }; + self.push( + ASTType::PackageDeclarationOpt0(Some(package_declaration_opt0_0_built)), + context, + ); + Ok(()) + } + + /// Semantic action for production 862: + /// + /// `PackageDeclarationOpt0 /* Option::None */: ;` + /// + #[parol_runtime::function_name::named] + fn package_declaration_opt0_1(&mut self) -> Result<()> { + let context = function_name!(); + trace!("{}", self.trace_item_stack(context)); + self.push(ASTType::PackageDeclarationOpt0(None), context); + Ok(()) + } + + /// Semantic action for production 863: /// /// `PackageDeclarationOpt /* Option::Some */: Pub;` /// @@ -30800,7 +31907,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 832: + /// Semantic action for production 864: /// /// `PackageDeclarationOpt /* Option::None */: ;` /// @@ -30812,7 +31919,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 833: + /// Semantic action for production 865: /// /// `PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup;` /// @@ -30837,7 +31944,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 834: + /// Semantic action for production 866: /// /// `PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace;` /// @@ -30872,7 +31979,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 835: + /// Semantic action for production 867: /// /// `PackageGroupGroupList /* Vec::Push */: PackageGroup PackageGroupGroupList;` /// @@ -30903,7 +32010,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 836: + /// Semantic action for production 868: /// /// `PackageGroupGroupList /* Vec::New */: ;` /// @@ -30919,7 +32026,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 837: + /// Semantic action for production 869: /// /// `PackageGroupGroup: PackageItem;` /// @@ -30940,7 +32047,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 838: + /// Semantic action for production 870: /// /// `PackageGroupList /* Vec::Push */: Attribute PackageGroupList;` /// @@ -30963,7 +32070,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 839: + /// Semantic action for production 871: /// /// `PackageGroupList /* Vec::New */: ;` /// @@ -30979,7 +32086,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 840: + /// Semantic action for production 872: /// /// `PackageItem: VarDeclaration;` /// @@ -30998,7 +32105,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 841: + /// Semantic action for production 873: /// /// `PackageItem: LocalDeclaration;` /// @@ -31017,7 +32124,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 842: + /// Semantic action for production 874: /// /// `PackageItem: TypeDefDeclaration;` /// @@ -31037,7 +32144,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 843: + /// Semantic action for production 875: /// /// `PackageItem: EnumDeclaration;` /// @@ -31056,7 +32163,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 844: + /// Semantic action for production 876: /// /// `PackageItem: StructUnionDeclaration;` /// @@ -31080,7 +32187,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 845: + /// Semantic action for production 877: /// /// `PackageItem: FunctionDeclaration;` /// @@ -31100,7 +32207,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 846: + /// Semantic action for production 878: /// /// `PackageItem: ImportDeclaration;` /// @@ -31119,7 +32226,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 847: + /// Semantic action for production 879: /// /// `PackageItem: ExportDeclaration;` /// @@ -31138,7 +32245,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 848: + /// Semantic action for production 880: /// /// `PackageItem: InitialDeclaration;` /// @@ -31157,7 +32264,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 849: + /// Semantic action for production 881: /// /// `PackageItem: FinalDeclaration;` /// @@ -31176,7 +32283,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 850: + /// Semantic action for production 882: /// /// `EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent;` /// @@ -31213,7 +32320,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 851: + /// Semantic action for production 883: /// /// `EmbedContent: EmbedContentToken : VerylToken;` /// @@ -31233,7 +32340,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 852: + /// Semantic action for production 884: /// /// `EmbedContentToken: LBraceTerm %push(Embed) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm %pop();` /// @@ -31281,7 +32388,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 853: + /// Semantic action for production 885: /// /// `EmbedContentTokenList /* Vec::Push */: EmbedItem EmbedContentTokenList;` /// @@ -31312,7 +32419,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 854: + /// Semantic action for production 886: /// /// `EmbedContentTokenList /* Vec::New */: ;` /// @@ -31328,7 +32435,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 855: + /// Semantic action for production 887: /// /// `EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm;` /// @@ -31356,7 +32463,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 856: + /// Semantic action for production 888: /// /// `EmbedItemList /* Vec::Push */: EmbedItem EmbedItemList;` /// @@ -31379,7 +32486,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 857: + /// Semantic action for production 889: /// /// `EmbedItemList /* Vec::New */: ;` /// @@ -31392,7 +32499,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 858: + /// Semantic action for production 890: /// /// `EmbedItem: AnyTerm;` /// @@ -31411,7 +32518,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 859: + /// Semantic action for production 891: /// /// `IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon;` /// @@ -31454,7 +32561,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 860: + /// Semantic action for production 892: /// /// `DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup;` /// @@ -31485,7 +32592,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 861: + /// Semantic action for production 893: /// /// `DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace;` /// @@ -31523,7 +32630,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 862: + /// Semantic action for production 894: /// /// `DescriptionGroupGroupList /* Vec::Push */: DescriptionGroup DescriptionGroupGroupList;` /// @@ -31554,7 +32661,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 863: + /// Semantic action for production 895: /// /// `DescriptionGroupGroupList /* Vec::New */: ;` /// @@ -31570,7 +32677,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 864: + /// Semantic action for production 896: /// /// `DescriptionGroupGroup: DescriptionItem;` /// @@ -31591,7 +32698,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 865: + /// Semantic action for production 897: /// /// `DescriptionGroupList /* Vec::Push */: Attribute DescriptionGroupList;` /// @@ -31618,7 +32725,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 866: + /// Semantic action for production 898: /// /// `DescriptionGroupList /* Vec::New */: ;` /// @@ -31634,7 +32741,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 867: + /// Semantic action for production 899: /// /// `DescriptionItem: ModuleDeclaration;` /// @@ -31654,7 +32761,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 868: + /// Semantic action for production 900: /// /// `DescriptionItem: InterfaceDeclaration;` /// @@ -31676,7 +32783,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 869: + /// Semantic action for production 901: /// /// `DescriptionItem: PackageDeclaration;` /// @@ -31697,7 +32804,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 870: + /// Semantic action for production 902: /// /// `DescriptionItem: ImportDeclaration;` /// @@ -31717,7 +32824,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 871: + /// Semantic action for production 903: /// /// `DescriptionItem: EmbedDeclaration;` /// @@ -31737,7 +32844,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 872: + /// Semantic action for production 904: /// /// `DescriptionItem: IncludeDeclaration;` /// @@ -31758,7 +32865,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 873: + /// Semantic action for production 905: /// /// `Veryl: Start VerylList /* Vec */;` /// @@ -31778,7 +32885,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 874: + /// Semantic action for production 906: /// /// `VerylList /* Vec::Push */: DescriptionGroup VerylList;` /// @@ -31801,7 +32908,7 @@ impl<'t, 'u> VerylGrammarAuto<'t, 'u> { Ok(()) } - /// Semantic action for production 875: + /// Semantic action for production 907: /// /// `VerylList /* Vec::New */: ;` /// @@ -31848,433 +32955,445 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { 20 => self.operator04_term(&children[0]), 21 => self.operator03_term(&children[0]), 22 => self.unary_operator_term(&children[0]), - 23 => self.colon_colon_term(&children[0]), - 24 => self.colon_term(&children[0]), - 25 => self.comma_term(&children[0]), - 26 => self.dot_dot_equ_term(&children[0]), - 27 => self.dot_dot_term(&children[0]), - 28 => self.dot_term(&children[0]), - 29 => self.equ_term(&children[0]), - 30 => self.hash_term(&children[0]), - 31 => self.l_angle_term(&children[0]), - 32 => self.quote_l_brace_term(&children[0]), - 33 => self.l_brace_term(&children[0]), - 34 => self.l_bracket_term(&children[0]), - 35 => self.l_paren_term(&children[0]), - 36 => self.r_angle_term(&children[0]), - 37 => self.r_brace_term(&children[0]), - 38 => self.r_bracket_term(&children[0]), - 39 => self.r_paren_term(&children[0]), - 40 => self.semicolon_term(&children[0]), - 41 => self.star_term(&children[0]), - 42 => self.always_comb_term(&children[0]), - 43 => self.always_ff_term(&children[0]), - 44 => self.assign_term(&children[0]), - 45 => self.as_term(&children[0]), - 46 => self.bit_term(&children[0]), - 47 => self.case_term(&children[0]), - 48 => self.clock_term(&children[0]), - 49 => self.clock_posedge_term(&children[0]), - 50 => self.clock_negedge_term(&children[0]), - 51 => self.default_term(&children[0]), - 52 => self.else_term(&children[0]), - 53 => self.embed_term(&children[0]), - 54 => self.enum_term(&children[0]), - 55 => self.export_term(&children[0]), - 56 => self.f32_term(&children[0]), - 57 => self.f64_term(&children[0]), - 58 => self.final_term(&children[0]), - 59 => self.for_term(&children[0]), - 60 => self.function_term(&children[0]), - 61 => self.i32_term(&children[0]), - 62 => self.i64_term(&children[0]), - 63 => self.if_reset_term(&children[0]), - 64 => self.if_term(&children[0]), - 65 => self.import_term(&children[0]), - 66 => self.include_term(&children[0]), - 67 => self.initial_term(&children[0]), - 68 => self.inout_term(&children[0]), - 69 => self.input_term(&children[0]), - 70 => self.inside_term(&children[0]), - 71 => self.inst_term(&children[0]), - 72 => self.interface_term(&children[0]), - 73 => self.in_term(&children[0]), - 74 => self.let_term(&children[0]), - 75 => self.local_term(&children[0]), - 76 => self.logic_term(&children[0]), - 77 => self.lsb_term(&children[0]), - 78 => self.modport_term(&children[0]), - 79 => self.module_term(&children[0]), - 80 => self.msb_term(&children[0]), - 81 => self.output_term(&children[0]), - 82 => self.outside_term(&children[0]), - 83 => self.package_term(&children[0]), - 84 => self.param_term(&children[0]), - 85 => self.pub_term(&children[0]), - 86 => self.ref_term(&children[0]), - 87 => self.repeat_term(&children[0]), - 88 => self.reset_term(&children[0]), - 89 => self.reset_async_high_term(&children[0]), - 90 => self.reset_async_low_term(&children[0]), - 91 => self.reset_sync_high_term(&children[0]), - 92 => self.reset_sync_low_term(&children[0]), - 93 => self.return_term(&children[0]), - 94 => self.break_term(&children[0]), - 95 => self.signed_term(&children[0]), - 96 => self.step_term(&children[0]), - 97 => self.string_term(&children[0]), - 98 => self.struct_term(&children[0]), - 99 => self.tri_term(&children[0]), - 100 => self.type_term(&children[0]), - 101 => self.u32_term(&children[0]), - 102 => self.u64_term(&children[0]), - 103 => self.union_term(&children[0]), - 104 => self.var_term(&children[0]), - 105 => self.dollar_identifier_term(&children[0]), - 106 => self.identifier_term(&children[0]), - 107 => self.any_term(&children[0]), - 108 => self.comments(&children[0]), - 109 => self.comments_opt_0(&children[0]), - 110 => self.comments_opt_1(), - 111 => self.start_token(&children[0]), - 112 => self.string_literal_token(&children[0], &children[1]), - 113 => self.exponent_token(&children[0], &children[1]), - 114 => self.fixed_point_token(&children[0], &children[1]), - 115 => self.based_token(&children[0], &children[1]), - 116 => self.base_less_token(&children[0], &children[1]), - 117 => self.all_bit_token(&children[0], &children[1]), - 118 => self.assignment_operator_token(&children[0], &children[1]), - 119 => self.operator01_token(&children[0], &children[1]), - 120 => self.operator02_token(&children[0], &children[1]), - 121 => self.operator03_token(&children[0], &children[1]), - 122 => self.operator04_token(&children[0], &children[1]), - 123 => self.operator05_token(&children[0], &children[1]), - 124 => self.operator06_token(&children[0], &children[1]), - 125 => self.operator07_token(&children[0], &children[1]), - 126 => self.operator08_token(&children[0], &children[1]), - 127 => self.operator09_token(&children[0], &children[1]), - 128 => self.operator10_token(&children[0], &children[1]), - 129 => self.operator11_token(&children[0], &children[1]), - 130 => self.unary_operator_token(&children[0], &children[1]), - 131 => self.colon_token(&children[0], &children[1]), - 132 => self.colon_colon_token(&children[0], &children[1]), - 133 => self.comma_token(&children[0], &children[1]), - 134 => self.dot_dot_token(&children[0], &children[1]), - 135 => self.dot_dot_equ_token(&children[0], &children[1]), - 136 => self.dot_token(&children[0], &children[1]), - 137 => self.equ_token(&children[0], &children[1]), - 138 => self.hash_token(&children[0], &children[1]), - 139 => self.quote_l_brace_token(&children[0], &children[1]), - 140 => self.l_angle_token(&children[0], &children[1]), - 141 => self.l_brace_token(&children[0], &children[1]), - 142 => self.l_bracket_token(&children[0], &children[1]), - 143 => self.l_paren_token(&children[0], &children[1]), - 144 => self.minus_colon_token(&children[0], &children[1]), - 145 => self.minus_g_t_token(&children[0], &children[1]), - 146 => self.plus_colon_token(&children[0], &children[1]), - 147 => self.r_angle_token(&children[0], &children[1]), - 148 => self.r_brace_token(&children[0], &children[1]), - 149 => self.r_bracket_token(&children[0], &children[1]), - 150 => self.r_paren_token(&children[0], &children[1]), - 151 => self.semicolon_token(&children[0], &children[1]), - 152 => self.star_token(&children[0], &children[1]), - 153 => self.always_comb_token(&children[0], &children[1]), - 154 => self.always_ff_token(&children[0], &children[1]), - 155 => self.as_token(&children[0], &children[1]), - 156 => self.assign_token(&children[0], &children[1]), - 157 => self.bit_token(&children[0], &children[1]), - 158 => self.case_token(&children[0], &children[1]), - 159 => self.clock_token(&children[0], &children[1]), - 160 => self.clock_posedge_token(&children[0], &children[1]), - 161 => self.clock_negedge_token(&children[0], &children[1]), - 162 => self.default_token(&children[0], &children[1]), - 163 => self.else_token(&children[0], &children[1]), - 164 => self.embed_token(&children[0], &children[1]), - 165 => self.enum_token(&children[0], &children[1]), - 166 => self.export_token(&children[0], &children[1]), - 167 => self.f32_token(&children[0], &children[1]), - 168 => self.f64_token(&children[0], &children[1]), - 169 => self.final_token(&children[0], &children[1]), - 170 => self.for_token(&children[0], &children[1]), - 171 => self.function_token(&children[0], &children[1]), - 172 => self.i32_token(&children[0], &children[1]), - 173 => self.i64_token(&children[0], &children[1]), - 174 => self.if_reset_token(&children[0], &children[1]), - 175 => self.if_token(&children[0], &children[1]), - 176 => self.import_token(&children[0], &children[1]), - 177 => self.include_token(&children[0], &children[1]), - 178 => self.initial_token(&children[0], &children[1]), - 179 => self.inout_token(&children[0], &children[1]), - 180 => self.input_token(&children[0], &children[1]), - 181 => self.inside_token(&children[0], &children[1]), - 182 => self.inst_token(&children[0], &children[1]), - 183 => self.interface_token(&children[0], &children[1]), - 184 => self.in_token(&children[0], &children[1]), - 185 => self.let_token(&children[0], &children[1]), - 186 => self.local_token(&children[0], &children[1]), - 187 => self.logic_token(&children[0], &children[1]), - 188 => self.lsb_token(&children[0], &children[1]), - 189 => self.modport_token(&children[0], &children[1]), - 190 => self.module_token(&children[0], &children[1]), - 191 => self.msb_token(&children[0], &children[1]), - 192 => self.output_token(&children[0], &children[1]), - 193 => self.outside_token(&children[0], &children[1]), - 194 => self.package_token(&children[0], &children[1]), - 195 => self.param_token(&children[0], &children[1]), - 196 => self.pub_token(&children[0], &children[1]), - 197 => self.ref_token(&children[0], &children[1]), - 198 => self.repeat_token(&children[0], &children[1]), - 199 => self.reset_token(&children[0], &children[1]), - 200 => self.reset_async_high_token(&children[0], &children[1]), - 201 => self.reset_async_low_token(&children[0], &children[1]), - 202 => self.reset_sync_high_token(&children[0], &children[1]), - 203 => self.reset_sync_low_token(&children[0], &children[1]), - 204 => self.return_token(&children[0], &children[1]), - 205 => self.break_token(&children[0], &children[1]), - 206 => self.signed_token(&children[0], &children[1]), - 207 => self.step_token(&children[0], &children[1]), - 208 => self.string_token(&children[0], &children[1]), - 209 => self.struct_token(&children[0], &children[1]), - 210 => self.tri_token(&children[0], &children[1]), - 211 => self.type_token(&children[0], &children[1]), - 212 => self.u32_token(&children[0], &children[1]), - 213 => self.u64_token(&children[0], &children[1]), - 214 => self.union_token(&children[0], &children[1]), - 215 => self.var_token(&children[0], &children[1]), - 216 => self.dollar_identifier_token(&children[0], &children[1]), - 217 => self.identifier_token(&children[0], &children[1]), - 218 => self.start(&children[0]), - 219 => self.string_literal(&children[0]), - 220 => self.exponent(&children[0]), - 221 => self.fixed_point(&children[0]), - 222 => self.based(&children[0]), - 223 => self.base_less(&children[0]), - 224 => self.all_bit(&children[0]), - 225 => self.assignment_operator(&children[0]), - 226 => self.operator01(&children[0]), - 227 => self.operator02(&children[0]), - 228 => self.operator03(&children[0]), - 229 => self.operator04(&children[0]), - 230 => self.operator05(&children[0]), - 231 => self.operator06(&children[0]), - 232 => self.operator07(&children[0]), - 233 => self.operator08(&children[0]), - 234 => self.operator09(&children[0]), - 235 => self.operator10(&children[0]), - 236 => self.operator11(&children[0]), - 237 => self.unary_operator(&children[0]), - 238 => self.colon(&children[0]), - 239 => self.colon_colon(&children[0]), - 240 => self.comma(&children[0]), - 241 => self.dot_dot(&children[0]), - 242 => self.dot_dot_equ(&children[0]), - 243 => self.dot(&children[0]), - 244 => self.equ(&children[0]), - 245 => self.hash(&children[0]), - 246 => self.quote_l_brace(&children[0]), - 247 => self.l_angle(&children[0]), - 248 => self.l_brace(&children[0]), - 249 => self.l_bracket(&children[0]), - 250 => self.l_paren(&children[0]), - 251 => self.minus_colon(&children[0]), - 252 => self.minus_g_t(&children[0]), - 253 => self.plus_colon(&children[0]), - 254 => self.r_angle(&children[0]), - 255 => self.r_brace(&children[0]), - 256 => self.r_bracket(&children[0]), - 257 => self.r_paren(&children[0]), - 258 => self.semicolon(&children[0]), - 259 => self.star(&children[0]), - 260 => self.always_comb(&children[0]), - 261 => self.always_ff(&children[0]), - 262 => self.r#as(&children[0]), - 263 => self.assign(&children[0]), - 264 => self.bit(&children[0]), - 265 => self.r#break(&children[0]), - 266 => self.case(&children[0]), - 267 => self.clock(&children[0]), - 268 => self.clock_posedge(&children[0]), - 269 => self.clock_negedge(&children[0]), - 270 => self.defaul(&children[0]), - 271 => self.r#else(&children[0]), - 272 => self.embed(&children[0]), - 273 => self.r#enum(&children[0]), - 274 => self.export(&children[0]), - 275 => self.f32(&children[0]), - 276 => self.f64(&children[0]), - 277 => self.r#final(&children[0]), - 278 => self.r#for(&children[0]), - 279 => self.function(&children[0]), - 280 => self.i32(&children[0]), - 281 => self.i64(&children[0]), - 282 => self.r#if(&children[0]), - 283 => self.if_reset(&children[0]), - 284 => self.import(&children[0]), - 285 => self.r#in(&children[0]), - 286 => self.include(&children[0]), - 287 => self.initial(&children[0]), - 288 => self.inout(&children[0]), - 289 => self.input(&children[0]), - 290 => self.inside(&children[0]), - 291 => self.inst(&children[0]), - 292 => self.interface(&children[0]), - 293 => self.r#let(&children[0]), - 294 => self.local(&children[0]), - 295 => self.logic(&children[0]), - 296 => self.lsb(&children[0]), - 297 => self.modport(&children[0]), - 298 => self.module(&children[0]), - 299 => self.msb(&children[0]), - 300 => self.output(&children[0]), - 301 => self.outside(&children[0]), - 302 => self.package(&children[0]), - 303 => self.param(&children[0]), - 304 => self.r#pub(&children[0]), - 305 => self.r#ref(&children[0]), - 306 => self.repeat(&children[0]), - 307 => self.reset(&children[0]), - 308 => self.reset_async_high(&children[0]), - 309 => self.reset_async_low(&children[0]), - 310 => self.reset_sync_high(&children[0]), - 311 => self.reset_sync_low(&children[0]), - 312 => self.r#return(&children[0]), - 313 => self.signed(&children[0]), - 314 => self.step(&children[0]), - 315 => self.strin(&children[0]), - 316 => self.r#struct(&children[0]), - 317 => self.tri(&children[0]), - 318 => self.r#type(&children[0]), - 319 => self.u32(&children[0]), - 320 => self.u64(&children[0]), - 321 => self.r#union(&children[0]), - 322 => self.var(&children[0]), - 323 => self.dollar_identifier(&children[0]), - 324 => self.identifier(&children[0]), - 325 => self.number_0(&children[0]), - 326 => self.number_1(&children[0]), - 327 => self.integral_number_0(&children[0]), - 328 => self.integral_number_1(&children[0]), - 329 => self.integral_number_2(&children[0]), - 330 => self.real_number_0(&children[0]), - 331 => self.real_number_1(&children[0]), - 332 => self.hierarchical_identifier(&children[0], &children[1], &children[2]), - 333 => self.hierarchical_identifier_list0_0( + 23 => self.colon_colon_l_angle_term(&children[0]), + 24 => self.colon_colon_term(&children[0]), + 25 => self.colon_term(&children[0]), + 26 => self.comma_term(&children[0]), + 27 => self.dot_dot_equ_term(&children[0]), + 28 => self.dot_dot_term(&children[0]), + 29 => self.dot_term(&children[0]), + 30 => self.equ_term(&children[0]), + 31 => self.hash_term(&children[0]), + 32 => self.l_angle_term(&children[0]), + 33 => self.quote_l_brace_term(&children[0]), + 34 => self.l_brace_term(&children[0]), + 35 => self.l_bracket_term(&children[0]), + 36 => self.l_paren_term(&children[0]), + 37 => self.r_angle_term(&children[0]), + 38 => self.r_brace_term(&children[0]), + 39 => self.r_bracket_term(&children[0]), + 40 => self.r_paren_term(&children[0]), + 41 => self.semicolon_term(&children[0]), + 42 => self.star_term(&children[0]), + 43 => self.always_comb_term(&children[0]), + 44 => self.always_ff_term(&children[0]), + 45 => self.assign_term(&children[0]), + 46 => self.as_term(&children[0]), + 47 => self.bit_term(&children[0]), + 48 => self.case_term(&children[0]), + 49 => self.clock_term(&children[0]), + 50 => self.clock_posedge_term(&children[0]), + 51 => self.clock_negedge_term(&children[0]), + 52 => self.default_term(&children[0]), + 53 => self.else_term(&children[0]), + 54 => self.embed_term(&children[0]), + 55 => self.enum_term(&children[0]), + 56 => self.export_term(&children[0]), + 57 => self.f32_term(&children[0]), + 58 => self.f64_term(&children[0]), + 59 => self.final_term(&children[0]), + 60 => self.for_term(&children[0]), + 61 => self.function_term(&children[0]), + 62 => self.i32_term(&children[0]), + 63 => self.i64_term(&children[0]), + 64 => self.if_reset_term(&children[0]), + 65 => self.if_term(&children[0]), + 66 => self.import_term(&children[0]), + 67 => self.include_term(&children[0]), + 68 => self.initial_term(&children[0]), + 69 => self.inout_term(&children[0]), + 70 => self.input_term(&children[0]), + 71 => self.inside_term(&children[0]), + 72 => self.inst_term(&children[0]), + 73 => self.interface_term(&children[0]), + 74 => self.in_term(&children[0]), + 75 => self.let_term(&children[0]), + 76 => self.local_term(&children[0]), + 77 => self.logic_term(&children[0]), + 78 => self.lsb_term(&children[0]), + 79 => self.modport_term(&children[0]), + 80 => self.module_term(&children[0]), + 81 => self.msb_term(&children[0]), + 82 => self.output_term(&children[0]), + 83 => self.outside_term(&children[0]), + 84 => self.package_term(&children[0]), + 85 => self.param_term(&children[0]), + 86 => self.pub_term(&children[0]), + 87 => self.ref_term(&children[0]), + 88 => self.repeat_term(&children[0]), + 89 => self.reset_term(&children[0]), + 90 => self.reset_async_high_term(&children[0]), + 91 => self.reset_async_low_term(&children[0]), + 92 => self.reset_sync_high_term(&children[0]), + 93 => self.reset_sync_low_term(&children[0]), + 94 => self.return_term(&children[0]), + 95 => self.break_term(&children[0]), + 96 => self.signed_term(&children[0]), + 97 => self.step_term(&children[0]), + 98 => self.string_term(&children[0]), + 99 => self.struct_term(&children[0]), + 100 => self.tri_term(&children[0]), + 101 => self.type_term(&children[0]), + 102 => self.u32_term(&children[0]), + 103 => self.u64_term(&children[0]), + 104 => self.union_term(&children[0]), + 105 => self.var_term(&children[0]), + 106 => self.dollar_identifier_term(&children[0]), + 107 => self.identifier_term(&children[0]), + 108 => self.any_term(&children[0]), + 109 => self.comments(&children[0]), + 110 => self.comments_opt_0(&children[0]), + 111 => self.comments_opt_1(), + 112 => self.start_token(&children[0]), + 113 => self.string_literal_token(&children[0], &children[1]), + 114 => self.exponent_token(&children[0], &children[1]), + 115 => self.fixed_point_token(&children[0], &children[1]), + 116 => self.based_token(&children[0], &children[1]), + 117 => self.base_less_token(&children[0], &children[1]), + 118 => self.all_bit_token(&children[0], &children[1]), + 119 => self.assignment_operator_token(&children[0], &children[1]), + 120 => self.operator01_token(&children[0], &children[1]), + 121 => self.operator02_token(&children[0], &children[1]), + 122 => self.operator03_token(&children[0], &children[1]), + 123 => self.operator04_token(&children[0], &children[1]), + 124 => self.operator05_token(&children[0], &children[1]), + 125 => self.operator06_token(&children[0], &children[1]), + 126 => self.operator07_token(&children[0], &children[1]), + 127 => self.operator08_token(&children[0], &children[1]), + 128 => self.operator09_token(&children[0], &children[1]), + 129 => self.operator10_token(&children[0], &children[1]), + 130 => self.operator11_token(&children[0], &children[1]), + 131 => self.unary_operator_token(&children[0], &children[1]), + 132 => self.colon_token(&children[0], &children[1]), + 133 => self.colon_colon_l_angle_token(&children[0], &children[1]), + 134 => self.colon_colon_token(&children[0], &children[1]), + 135 => self.comma_token(&children[0], &children[1]), + 136 => self.dot_dot_token(&children[0], &children[1]), + 137 => self.dot_dot_equ_token(&children[0], &children[1]), + 138 => self.dot_token(&children[0], &children[1]), + 139 => self.equ_token(&children[0], &children[1]), + 140 => self.hash_token(&children[0], &children[1]), + 141 => self.quote_l_brace_token(&children[0], &children[1]), + 142 => self.l_angle_token(&children[0], &children[1]), + 143 => self.l_brace_token(&children[0], &children[1]), + 144 => self.l_bracket_token(&children[0], &children[1]), + 145 => self.l_paren_token(&children[0], &children[1]), + 146 => self.minus_colon_token(&children[0], &children[1]), + 147 => self.minus_g_t_token(&children[0], &children[1]), + 148 => self.plus_colon_token(&children[0], &children[1]), + 149 => self.r_angle_token(&children[0], &children[1]), + 150 => self.r_brace_token(&children[0], &children[1]), + 151 => self.r_bracket_token(&children[0], &children[1]), + 152 => self.r_paren_token(&children[0], &children[1]), + 153 => self.semicolon_token(&children[0], &children[1]), + 154 => self.star_token(&children[0], &children[1]), + 155 => self.always_comb_token(&children[0], &children[1]), + 156 => self.always_ff_token(&children[0], &children[1]), + 157 => self.as_token(&children[0], &children[1]), + 158 => self.assign_token(&children[0], &children[1]), + 159 => self.bit_token(&children[0], &children[1]), + 160 => self.case_token(&children[0], &children[1]), + 161 => self.clock_token(&children[0], &children[1]), + 162 => self.clock_posedge_token(&children[0], &children[1]), + 163 => self.clock_negedge_token(&children[0], &children[1]), + 164 => self.default_token(&children[0], &children[1]), + 165 => self.else_token(&children[0], &children[1]), + 166 => self.embed_token(&children[0], &children[1]), + 167 => self.enum_token(&children[0], &children[1]), + 168 => self.export_token(&children[0], &children[1]), + 169 => self.f32_token(&children[0], &children[1]), + 170 => self.f64_token(&children[0], &children[1]), + 171 => self.final_token(&children[0], &children[1]), + 172 => self.for_token(&children[0], &children[1]), + 173 => self.function_token(&children[0], &children[1]), + 174 => self.i32_token(&children[0], &children[1]), + 175 => self.i64_token(&children[0], &children[1]), + 176 => self.if_reset_token(&children[0], &children[1]), + 177 => self.if_token(&children[0], &children[1]), + 178 => self.import_token(&children[0], &children[1]), + 179 => self.include_token(&children[0], &children[1]), + 180 => self.initial_token(&children[0], &children[1]), + 181 => self.inout_token(&children[0], &children[1]), + 182 => self.input_token(&children[0], &children[1]), + 183 => self.inside_token(&children[0], &children[1]), + 184 => self.inst_token(&children[0], &children[1]), + 185 => self.interface_token(&children[0], &children[1]), + 186 => self.in_token(&children[0], &children[1]), + 187 => self.let_token(&children[0], &children[1]), + 188 => self.local_token(&children[0], &children[1]), + 189 => self.logic_token(&children[0], &children[1]), + 190 => self.lsb_token(&children[0], &children[1]), + 191 => self.modport_token(&children[0], &children[1]), + 192 => self.module_token(&children[0], &children[1]), + 193 => self.msb_token(&children[0], &children[1]), + 194 => self.output_token(&children[0], &children[1]), + 195 => self.outside_token(&children[0], &children[1]), + 196 => self.package_token(&children[0], &children[1]), + 197 => self.param_token(&children[0], &children[1]), + 198 => self.pub_token(&children[0], &children[1]), + 199 => self.ref_token(&children[0], &children[1]), + 200 => self.repeat_token(&children[0], &children[1]), + 201 => self.reset_token(&children[0], &children[1]), + 202 => self.reset_async_high_token(&children[0], &children[1]), + 203 => self.reset_async_low_token(&children[0], &children[1]), + 204 => self.reset_sync_high_token(&children[0], &children[1]), + 205 => self.reset_sync_low_token(&children[0], &children[1]), + 206 => self.return_token(&children[0], &children[1]), + 207 => self.break_token(&children[0], &children[1]), + 208 => self.signed_token(&children[0], &children[1]), + 209 => self.step_token(&children[0], &children[1]), + 210 => self.string_token(&children[0], &children[1]), + 211 => self.struct_token(&children[0], &children[1]), + 212 => self.tri_token(&children[0], &children[1]), + 213 => self.type_token(&children[0], &children[1]), + 214 => self.u32_token(&children[0], &children[1]), + 215 => self.u64_token(&children[0], &children[1]), + 216 => self.union_token(&children[0], &children[1]), + 217 => self.var_token(&children[0], &children[1]), + 218 => self.dollar_identifier_token(&children[0], &children[1]), + 219 => self.identifier_token(&children[0], &children[1]), + 220 => self.start(&children[0]), + 221 => self.string_literal(&children[0]), + 222 => self.exponent(&children[0]), + 223 => self.fixed_point(&children[0]), + 224 => self.based(&children[0]), + 225 => self.base_less(&children[0]), + 226 => self.all_bit(&children[0]), + 227 => self.assignment_operator(&children[0]), + 228 => self.operator01(&children[0]), + 229 => self.operator02(&children[0]), + 230 => self.operator03(&children[0]), + 231 => self.operator04(&children[0]), + 232 => self.operator05(&children[0]), + 233 => self.operator06(&children[0]), + 234 => self.operator07(&children[0]), + 235 => self.operator08(&children[0]), + 236 => self.operator09(&children[0]), + 237 => self.operator10(&children[0]), + 238 => self.operator11(&children[0]), + 239 => self.unary_operator(&children[0]), + 240 => self.colon(&children[0]), + 241 => self.colon_colon_l_angle(&children[0]), + 242 => self.colon_colon(&children[0]), + 243 => self.comma(&children[0]), + 244 => self.dot_dot(&children[0]), + 245 => self.dot_dot_equ(&children[0]), + 246 => self.dot(&children[0]), + 247 => self.equ(&children[0]), + 248 => self.hash(&children[0]), + 249 => self.quote_l_brace(&children[0]), + 250 => self.l_angle(&children[0]), + 251 => self.l_brace(&children[0]), + 252 => self.l_bracket(&children[0]), + 253 => self.l_paren(&children[0]), + 254 => self.minus_colon(&children[0]), + 255 => self.minus_g_t(&children[0]), + 256 => self.plus_colon(&children[0]), + 257 => self.r_angle(&children[0]), + 258 => self.r_brace(&children[0]), + 259 => self.r_bracket(&children[0]), + 260 => self.r_paren(&children[0]), + 261 => self.semicolon(&children[0]), + 262 => self.star(&children[0]), + 263 => self.always_comb(&children[0]), + 264 => self.always_ff(&children[0]), + 265 => self.r#as(&children[0]), + 266 => self.assign(&children[0]), + 267 => self.bit(&children[0]), + 268 => self.r#break(&children[0]), + 269 => self.case(&children[0]), + 270 => self.clock(&children[0]), + 271 => self.clock_posedge(&children[0]), + 272 => self.clock_negedge(&children[0]), + 273 => self.defaul(&children[0]), + 274 => self.r#else(&children[0]), + 275 => self.embed(&children[0]), + 276 => self.r#enum(&children[0]), + 277 => self.export(&children[0]), + 278 => self.f32(&children[0]), + 279 => self.f64(&children[0]), + 280 => self.r#final(&children[0]), + 281 => self.r#for(&children[0]), + 282 => self.function(&children[0]), + 283 => self.i32(&children[0]), + 284 => self.i64(&children[0]), + 285 => self.r#if(&children[0]), + 286 => self.if_reset(&children[0]), + 287 => self.import(&children[0]), + 288 => self.r#in(&children[0]), + 289 => self.include(&children[0]), + 290 => self.initial(&children[0]), + 291 => self.inout(&children[0]), + 292 => self.input(&children[0]), + 293 => self.inside(&children[0]), + 294 => self.inst(&children[0]), + 295 => self.interface(&children[0]), + 296 => self.r#let(&children[0]), + 297 => self.local(&children[0]), + 298 => self.logic(&children[0]), + 299 => self.lsb(&children[0]), + 300 => self.modport(&children[0]), + 301 => self.module(&children[0]), + 302 => self.msb(&children[0]), + 303 => self.output(&children[0]), + 304 => self.outside(&children[0]), + 305 => self.package(&children[0]), + 306 => self.param(&children[0]), + 307 => self.r#pub(&children[0]), + 308 => self.r#ref(&children[0]), + 309 => self.repeat(&children[0]), + 310 => self.reset(&children[0]), + 311 => self.reset_async_high(&children[0]), + 312 => self.reset_async_low(&children[0]), + 313 => self.reset_sync_high(&children[0]), + 314 => self.reset_sync_low(&children[0]), + 315 => self.r#return(&children[0]), + 316 => self.signed(&children[0]), + 317 => self.step(&children[0]), + 318 => self.strin(&children[0]), + 319 => self.r#struct(&children[0]), + 320 => self.tri(&children[0]), + 321 => self.r#type(&children[0]), + 322 => self.u32(&children[0]), + 323 => self.u64(&children[0]), + 324 => self.r#union(&children[0]), + 325 => self.var(&children[0]), + 326 => self.dollar_identifier(&children[0]), + 327 => self.identifier(&children[0]), + 328 => self.number_0(&children[0]), + 329 => self.number_1(&children[0]), + 330 => self.integral_number_0(&children[0]), + 331 => self.integral_number_1(&children[0]), + 332 => self.integral_number_2(&children[0]), + 333 => self.real_number_0(&children[0]), + 334 => self.real_number_1(&children[0]), + 335 => self.hierarchical_identifier(&children[0], &children[1], &children[2]), + 336 => self.hierarchical_identifier_list0_0( + &children[0], + &children[1], + &children[2], + &children[3], + ), + 337 => self.hierarchical_identifier_list0_list_0(&children[0], &children[1]), + 338 => self.hierarchical_identifier_list0_list_1(), + 339 => self.hierarchical_identifier_list0_1(), + 340 => self.hierarchical_identifier_list_0(&children[0], &children[1]), + 341 => self.hierarchical_identifier_list_1(), + 342 => self.scoped_identifier(&children[0], &children[1]), + 343 => self.scoped_identifier_group_0(&children[0]), + 344 => self.scoped_identifier_group_1(&children[0], &children[1]), + 345 => self.scoped_identifier_list_0( &children[0], &children[1], &children[2], &children[3], ), - 334 => self.hierarchical_identifier_list0_list_0(&children[0], &children[1]), - 335 => self.hierarchical_identifier_list0_list_1(), - 336 => self.hierarchical_identifier_list0_1(), - 337 => self.hierarchical_identifier_list_0(&children[0], &children[1]), - 338 => self.hierarchical_identifier_list_1(), - 339 => self.scoped_identifier(&children[0], &children[1]), - 340 => self.scoped_identifier_group_0(&children[0]), - 341 => self.scoped_identifier_group_1(&children[0]), - 342 => self.scoped_identifier_list_0(&children[0], &children[1], &children[2]), - 343 => self.scoped_identifier_list_1(), - 344 => self.expression_identifier(&children[0], &children[1], &children[2]), - 345 => self.expression_identifier_list0_0( + 346 => self.scoped_identifier_list_1(), + 347 => self.scoped_identifier_opt0_0(&children[0]), + 348 => self.scoped_identifier_opt0_1(), + 349 => self.scoped_identifier_opt_0(&children[0]), + 350 => self.scoped_identifier_opt_1(), + 351 => self.expression_identifier(&children[0], &children[1], &children[2]), + 352 => self.expression_identifier_list0_0( &children[0], &children[1], &children[2], &children[3], ), - 346 => self.expression_identifier_list0_list_0(&children[0], &children[1]), - 347 => self.expression_identifier_list0_list_1(), - 348 => self.expression_identifier_list0_1(), - 349 => self.expression_identifier_list_0(&children[0], &children[1]), - 350 => self.expression_identifier_list_1(), - 351 => self.expression(&children[0], &children[1]), - 352 => self.expression_list_0(&children[0], &children[1], &children[2]), - 353 => self.expression_list_1(), - 354 => self.expression01(&children[0], &children[1]), - 355 => self.expression01_list_0(&children[0], &children[1], &children[2]), - 356 => self.expression01_list_1(), - 357 => self.expression02(&children[0], &children[1]), - 358 => self.expression02_list_0(&children[0], &children[1], &children[2]), - 359 => self.expression02_list_1(), - 360 => self.expression03(&children[0], &children[1]), - 361 => self.expression03_list_0(&children[0], &children[1], &children[2]), - 362 => self.expression03_list_1(), - 363 => self.expression04(&children[0], &children[1]), - 364 => self.expression04_list_0(&children[0], &children[1], &children[2]), - 365 => self.expression04_list_1(), - 366 => self.expression05(&children[0], &children[1]), - 367 => self.expression05_list_0(&children[0], &children[1], &children[2]), - 368 => self.expression05_list_1(), - 369 => self.expression06(&children[0], &children[1]), - 370 => self.expression06_list_0(&children[0], &children[1], &children[2]), - 371 => self.expression06_list_1(), - 372 => self.expression07(&children[0], &children[1]), - 373 => self.expression07_list_0(&children[0], &children[1], &children[2]), - 374 => self.expression07_list_1(), - 375 => self.expression08(&children[0], &children[1]), - 376 => self.expression08_list_0(&children[0], &children[1], &children[2]), - 377 => self.expression08_list_1(), - 378 => self.expression09(&children[0], &children[1]), - 379 => self.expression09_list_0(&children[0], &children[1], &children[2]), - 380 => self.expression09_list_group_0(&children[0]), - 381 => self.expression09_list_group_1(&children[0]), - 382 => self.expression09_list_1(), - 383 => self.expression10(&children[0], &children[1]), - 384 => self.expression10_list_0(&children[0], &children[1], &children[2]), - 385 => self.expression10_list_1(), - 386 => self.expression11(&children[0], &children[1]), - 387 => self.expression11_list_0(&children[0], &children[1], &children[2]), - 388 => self.expression11_list_1(), - 389 => self.expression12(&children[0], &children[1]), - 390 => self.expression12_list_0(&children[0], &children[1]), - 391 => self.expression12_list_group_0(&children[0]), - 392 => self.expression12_list_group_1(&children[0]), - 393 => self.expression12_list_group_2(&children[0]), - 394 => self.expression12_list_group_3(&children[0]), - 395 => self.expression12_list_group_4(&children[0]), - 396 => self.expression12_list_1(), - 397 => self.factor_0(&children[0]), - 398 => self.factor_1(&children[0], &children[1]), - 399 => self.factor_2(&children[0], &children[1], &children[2]), - 400 => self.factor_3(&children[0], &children[1], &children[2]), - 401 => self.factor_4(&children[0], &children[1], &children[2]), - 402 => self.factor_5(&children[0]), - 403 => self.factor_6(&children[0]), - 404 => self.factor_7(&children[0]), - 405 => self.factor_8(&children[0]), - 406 => self.factor_group_0(&children[0]), - 407 => self.factor_group_1(&children[0]), - 408 => self.factor_9(&children[0]), - 409 => self.factor_10(&children[0]), - 410 => self.factor_opt_0(&children[0]), - 411 => self.factor_opt_1(), - 412 => self.function_call(&children[0], &children[1], &children[2]), - 413 => self.function_call_opt_0(&children[0]), - 414 => self.function_call_opt_1(), - 415 => self.argument_list(&children[0], &children[1], &children[2]), - 416 => self.argument_list_list_0(&children[0], &children[1], &children[2]), - 417 => self.argument_list_list_1(), - 418 => self.argument_list_opt_0(&children[0]), - 419 => self.argument_list_opt_1(), - 420 => self.argument_item(&children[0]), - 421 => self.concatenation_list(&children[0], &children[1], &children[2]), - 422 => self.concatenation_list_list_0(&children[0], &children[1], &children[2]), - 423 => self.concatenation_list_list_1(), - 424 => self.concatenation_list_opt_0(&children[0]), - 425 => self.concatenation_list_opt_1(), - 426 => self.concatenation_item(&children[0], &children[1]), - 427 => self.concatenation_item_opt_0(&children[0], &children[1]), - 428 => self.concatenation_item_opt_1(), - 429 => self.array_literal_list(&children[0], &children[1], &children[2]), - 430 => self.array_literal_list_list_0(&children[0], &children[1], &children[2]), - 431 => self.array_literal_list_list_1(), - 432 => self.array_literal_list_opt_0(&children[0]), - 433 => self.array_literal_list_opt_1(), - 434 => self.array_literal_item(&children[0]), - 435 => self.array_literal_item_group_0(&children[0], &children[1]), - 436 => self.array_literal_item_group_1(&children[0], &children[1], &children[2]), - 437 => self.array_literal_item_opt_0(&children[0], &children[1]), - 438 => self.array_literal_item_opt_1(), - 439 => self.if_expression( + 353 => self.expression_identifier_list0_list_0(&children[0], &children[1]), + 354 => self.expression_identifier_list0_list_1(), + 355 => self.expression_identifier_list0_1(), + 356 => self.expression_identifier_list_0(&children[0], &children[1]), + 357 => self.expression_identifier_list_1(), + 358 => self.expression(&children[0], &children[1]), + 359 => self.expression_list_0(&children[0], &children[1], &children[2]), + 360 => self.expression_list_1(), + 361 => self.expression01(&children[0], &children[1]), + 362 => self.expression01_list_0(&children[0], &children[1], &children[2]), + 363 => self.expression01_list_1(), + 364 => self.expression02(&children[0], &children[1]), + 365 => self.expression02_list_0(&children[0], &children[1], &children[2]), + 366 => self.expression02_list_1(), + 367 => self.expression03(&children[0], &children[1]), + 368 => self.expression03_list_0(&children[0], &children[1], &children[2]), + 369 => self.expression03_list_1(), + 370 => self.expression04(&children[0], &children[1]), + 371 => self.expression04_list_0(&children[0], &children[1], &children[2]), + 372 => self.expression04_list_1(), + 373 => self.expression05(&children[0], &children[1]), + 374 => self.expression05_list_0(&children[0], &children[1], &children[2]), + 375 => self.expression05_list_1(), + 376 => self.expression06(&children[0], &children[1]), + 377 => self.expression06_list_0(&children[0], &children[1], &children[2]), + 378 => self.expression06_list_1(), + 379 => self.expression07(&children[0], &children[1]), + 380 => self.expression07_list_0(&children[0], &children[1], &children[2]), + 381 => self.expression07_list_1(), + 382 => self.expression08(&children[0], &children[1]), + 383 => self.expression08_list_0(&children[0], &children[1], &children[2]), + 384 => self.expression08_list_1(), + 385 => self.expression09(&children[0], &children[1]), + 386 => self.expression09_list_0(&children[0], &children[1], &children[2]), + 387 => self.expression09_list_group_0(&children[0]), + 388 => self.expression09_list_group_1(&children[0]), + 389 => self.expression09_list_1(), + 390 => self.expression10(&children[0], &children[1]), + 391 => self.expression10_list_0(&children[0], &children[1], &children[2]), + 392 => self.expression10_list_1(), + 393 => self.expression11(&children[0], &children[1]), + 394 => self.expression11_list_0(&children[0], &children[1], &children[2]), + 395 => self.expression11_list_1(), + 396 => self.expression12(&children[0], &children[1]), + 397 => self.expression12_list_0(&children[0], &children[1]), + 398 => self.expression12_list_group_0(&children[0]), + 399 => self.expression12_list_group_1(&children[0]), + 400 => self.expression12_list_group_2(&children[0]), + 401 => self.expression12_list_group_3(&children[0]), + 402 => self.expression12_list_group_4(&children[0]), + 403 => self.expression12_list_1(), + 404 => self.factor_0(&children[0]), + 405 => self.factor_1(&children[0], &children[1]), + 406 => self.factor_2(&children[0], &children[1], &children[2]), + 407 => self.factor_3(&children[0], &children[1], &children[2]), + 408 => self.factor_4(&children[0], &children[1], &children[2]), + 409 => self.factor_5(&children[0]), + 410 => self.factor_6(&children[0]), + 411 => self.factor_7(&children[0]), + 412 => self.factor_8(&children[0]), + 413 => self.factor_group_0(&children[0]), + 414 => self.factor_group_1(&children[0]), + 415 => self.factor_9(&children[0]), + 416 => self.factor_10(&children[0]), + 417 => self.factor_opt_0(&children[0]), + 418 => self.factor_opt_1(), + 419 => self.function_call(&children[0], &children[1], &children[2]), + 420 => self.function_call_opt_0(&children[0]), + 421 => self.function_call_opt_1(), + 422 => self.argument_list(&children[0], &children[1], &children[2]), + 423 => self.argument_list_list_0(&children[0], &children[1], &children[2]), + 424 => self.argument_list_list_1(), + 425 => self.argument_list_opt_0(&children[0]), + 426 => self.argument_list_opt_1(), + 427 => self.argument_item(&children[0]), + 428 => self.concatenation_list(&children[0], &children[1], &children[2]), + 429 => self.concatenation_list_list_0(&children[0], &children[1], &children[2]), + 430 => self.concatenation_list_list_1(), + 431 => self.concatenation_list_opt_0(&children[0]), + 432 => self.concatenation_list_opt_1(), + 433 => self.concatenation_item(&children[0], &children[1]), + 434 => self.concatenation_item_opt_0(&children[0], &children[1]), + 435 => self.concatenation_item_opt_1(), + 436 => self.array_literal_list(&children[0], &children[1], &children[2]), + 437 => self.array_literal_list_list_0(&children[0], &children[1], &children[2]), + 438 => self.array_literal_list_list_1(), + 439 => self.array_literal_list_opt_0(&children[0]), + 440 => self.array_literal_list_opt_1(), + 441 => self.array_literal_item(&children[0]), + 442 => self.array_literal_item_group_0(&children[0], &children[1]), + 443 => self.array_literal_item_group_1(&children[0], &children[1], &children[2]), + 444 => self.array_literal_item_opt_0(&children[0], &children[1]), + 445 => self.array_literal_item_opt_1(), + 446 => self.if_expression( &children[0], &children[1], &children[2], @@ -32286,7 +33405,7 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[8], &children[9], ), - 440 => self.if_expression_list_0( + 447 => self.if_expression_list_0( &children[0], &children[1], &children[2], @@ -32295,8 +33414,8 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 441 => self.if_expression_list_1(), - 442 => self.case_expression( + 448 => self.if_expression_list_1(), + 449 => self.case_expression( &children[0], &children[1], &children[2], @@ -32312,7 +33431,7 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[12], &children[13], ), - 443 => self.case_expression_list0_0( + 450 => self.case_expression_list0_0( &children[0], &children[1], &children[2], @@ -32320,93 +33439,93 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 444 => self.case_expression_list0_list_0(&children[0], &children[1], &children[2]), - 445 => self.case_expression_list0_list_1(), - 446 => self.case_expression_list0_1(), - 447 => self.case_expression_list_0(&children[0], &children[1], &children[2]), - 448 => self.case_expression_list_1(), - 449 => self.case_expression_opt_0(&children[0]), - 450 => self.case_expression_opt_1(), - 451 => self.type_expression_0(&children[0]), - 452 => self.type_expression_1(&children[0], &children[1], &children[2], &children[3]), - 453 => self.inside_expression( + 451 => self.case_expression_list0_list_0(&children[0], &children[1], &children[2]), + 452 => self.case_expression_list0_list_1(), + 453 => self.case_expression_list0_1(), + 454 => self.case_expression_list_0(&children[0], &children[1], &children[2]), + 455 => self.case_expression_list_1(), + 456 => self.case_expression_opt_0(&children[0]), + 457 => self.case_expression_opt_1(), + 458 => self.type_expression_0(&children[0]), + 459 => self.type_expression_1(&children[0], &children[1], &children[2], &children[3]), + 460 => self.inside_expression( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 454 => self.outside_expression( + 461 => self.outside_expression( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 455 => self.range_list(&children[0], &children[1], &children[2]), - 456 => self.range_list_list_0(&children[0], &children[1], &children[2]), - 457 => self.range_list_list_1(), - 458 => self.range_list_opt_0(&children[0]), - 459 => self.range_list_opt_1(), - 460 => self.range_item(&children[0]), - 461 => self.select(&children[0], &children[1], &children[2], &children[3]), - 462 => self.select_opt_0(&children[0], &children[1]), - 463 => self.select_opt_1(), - 464 => self.select_operator_0(&children[0]), - 465 => self.select_operator_1(&children[0]), - 466 => self.select_operator_2(&children[0]), - 467 => self.select_operator_3(&children[0]), - 468 => self.width(&children[0], &children[1], &children[2], &children[3]), - 469 => self.width_list_0(&children[0], &children[1], &children[2]), - 470 => self.width_list_1(), - 471 => self.array(&children[0], &children[1], &children[2], &children[3]), - 472 => self.array_list_0(&children[0], &children[1], &children[2]), - 473 => self.array_list_1(), - 474 => self.range(&children[0], &children[1]), - 475 => self.range_opt_0(&children[0], &children[1]), - 476 => self.range_opt_1(), - 477 => self.range_operator_0(&children[0]), - 478 => self.range_operator_1(&children[0]), - 479 => self.fixed_type_0(&children[0]), - 480 => self.fixed_type_1(&children[0]), - 481 => self.fixed_type_2(&children[0]), - 482 => self.fixed_type_3(&children[0]), - 483 => self.fixed_type_4(&children[0]), - 484 => self.fixed_type_5(&children[0]), - 485 => self.fixed_type_6(&children[0]), - 486 => self.variable_type(&children[0], &children[1]), - 487 => self.variable_type_group_0(&children[0]), - 488 => self.variable_type_group_1(&children[0]), - 489 => self.variable_type_group_2(&children[0]), - 490 => self.variable_type_group_3(&children[0]), - 491 => self.variable_type_group_4(&children[0]), - 492 => self.variable_type_group_5(&children[0]), - 493 => self.variable_type_group_6(&children[0]), - 494 => self.variable_type_group_7(&children[0]), - 495 => self.variable_type_group_8(&children[0]), - 496 => self.variable_type_group_9(&children[0]), - 497 => self.variable_type_group_10(&children[0]), - 498 => self.variable_type_opt_0(&children[0]), - 499 => self.variable_type_opt_1(), - 500 => self.type_modifier_0(&children[0]), - 501 => self.type_modifier_1(&children[0]), - 502 => self.scalar_type(&children[0], &children[1]), - 503 => self.scalar_type_group_0(&children[0]), - 504 => self.scalar_type_group_1(&children[0]), - 505 => self.scalar_type_list_0(&children[0], &children[1]), - 506 => self.scalar_type_list_1(), - 507 => self.array_type(&children[0], &children[1]), - 508 => self.array_type_opt_0(&children[0]), - 509 => self.array_type_opt_1(), - 510 => self.statement_0(&children[0]), - 511 => self.statement_1(&children[0]), - 512 => self.statement_2(&children[0]), - 513 => self.statement_3(&children[0]), - 514 => self.statement_4(&children[0]), - 515 => self.statement_5(&children[0]), - 516 => self.statement_6(&children[0]), - 517 => self.statement_7(&children[0]), - 518 => self.let_statement( + 462 => self.range_list(&children[0], &children[1], &children[2]), + 463 => self.range_list_list_0(&children[0], &children[1], &children[2]), + 464 => self.range_list_list_1(), + 465 => self.range_list_opt_0(&children[0]), + 466 => self.range_list_opt_1(), + 467 => self.range_item(&children[0]), + 468 => self.select(&children[0], &children[1], &children[2], &children[3]), + 469 => self.select_opt_0(&children[0], &children[1]), + 470 => self.select_opt_1(), + 471 => self.select_operator_0(&children[0]), + 472 => self.select_operator_1(&children[0]), + 473 => self.select_operator_2(&children[0]), + 474 => self.select_operator_3(&children[0]), + 475 => self.width(&children[0], &children[1], &children[2], &children[3]), + 476 => self.width_list_0(&children[0], &children[1], &children[2]), + 477 => self.width_list_1(), + 478 => self.array(&children[0], &children[1], &children[2], &children[3]), + 479 => self.array_list_0(&children[0], &children[1], &children[2]), + 480 => self.array_list_1(), + 481 => self.range(&children[0], &children[1]), + 482 => self.range_opt_0(&children[0], &children[1]), + 483 => self.range_opt_1(), + 484 => self.range_operator_0(&children[0]), + 485 => self.range_operator_1(&children[0]), + 486 => self.fixed_type_0(&children[0]), + 487 => self.fixed_type_1(&children[0]), + 488 => self.fixed_type_2(&children[0]), + 489 => self.fixed_type_3(&children[0]), + 490 => self.fixed_type_4(&children[0]), + 491 => self.fixed_type_5(&children[0]), + 492 => self.fixed_type_6(&children[0]), + 493 => self.variable_type(&children[0], &children[1]), + 494 => self.variable_type_group_0(&children[0]), + 495 => self.variable_type_group_1(&children[0]), + 496 => self.variable_type_group_2(&children[0]), + 497 => self.variable_type_group_3(&children[0]), + 498 => self.variable_type_group_4(&children[0]), + 499 => self.variable_type_group_5(&children[0]), + 500 => self.variable_type_group_6(&children[0]), + 501 => self.variable_type_group_7(&children[0]), + 502 => self.variable_type_group_8(&children[0]), + 503 => self.variable_type_group_9(&children[0]), + 504 => self.variable_type_group_10(&children[0]), + 505 => self.variable_type_opt_0(&children[0]), + 506 => self.variable_type_opt_1(), + 507 => self.type_modifier_0(&children[0]), + 508 => self.type_modifier_1(&children[0]), + 509 => self.scalar_type(&children[0], &children[1]), + 510 => self.scalar_type_group_0(&children[0]), + 511 => self.scalar_type_group_1(&children[0]), + 512 => self.scalar_type_list_0(&children[0], &children[1]), + 513 => self.scalar_type_list_1(), + 514 => self.array_type(&children[0], &children[1]), + 515 => self.array_type_opt_0(&children[0]), + 516 => self.array_type_opt_1(), + 517 => self.statement_0(&children[0]), + 518 => self.statement_1(&children[0]), + 519 => self.statement_2(&children[0]), + 520 => self.statement_3(&children[0]), + 521 => self.statement_4(&children[0]), + 522 => self.statement_5(&children[0]), + 523 => self.statement_6(&children[0]), + 524 => self.statement_7(&children[0]), + 525 => self.let_statement( &children[0], &children[1], &children[2], @@ -32415,13 +33534,13 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 519 => self.identifier_statement(&children[0], &children[1], &children[2]), - 520 => self.identifier_statement_group_0(&children[0]), - 521 => self.identifier_statement_group_1(&children[0]), - 522 => self.assignment(&children[0], &children[1]), - 523 => self.assignment_group_0(&children[0]), - 524 => self.assignment_group_1(&children[0]), - 525 => self.if_statement( + 526 => self.identifier_statement(&children[0], &children[1], &children[2]), + 527 => self.identifier_statement_group_0(&children[0]), + 528 => self.identifier_statement_group_1(&children[0]), + 529 => self.assignment(&children[0], &children[1]), + 530 => self.assignment_group_0(&children[0]), + 531 => self.assignment_group_1(&children[0]), + 532 => self.if_statement( &children[0], &children[1], &children[2], @@ -32430,7 +33549,7 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 526 => self.if_statement_list0_0( + 533 => self.if_statement_list0_0( &children[0], &children[1], &children[2], @@ -32439,16 +33558,16 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 527 => self.if_statement_list0_list_0(&children[0], &children[1]), - 528 => self.if_statement_list0_list_1(), - 529 => self.if_statement_list0_1(), - 530 => self.if_statement_list_0(&children[0], &children[1]), - 531 => self.if_statement_list_1(), - 532 => self.if_statement_opt_0(&children[0], &children[1], &children[2], &children[3]), - 533 => self.if_statement_opt_list_0(&children[0], &children[1]), - 534 => self.if_statement_opt_list_1(), - 535 => self.if_statement_opt_1(), - 536 => self.if_reset_statement( + 534 => self.if_statement_list0_list_0(&children[0], &children[1]), + 535 => self.if_statement_list0_list_1(), + 536 => self.if_statement_list0_1(), + 537 => self.if_statement_list_0(&children[0], &children[1]), + 538 => self.if_statement_list_1(), + 539 => self.if_statement_opt_0(&children[0], &children[1], &children[2], &children[3]), + 540 => self.if_statement_opt_list_0(&children[0], &children[1]), + 541 => self.if_statement_opt_list_1(), + 542 => self.if_statement_opt_1(), + 543 => self.if_reset_statement( &children[0], &children[1], &children[2], @@ -32456,7 +33575,7 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 537 => self.if_reset_statement_list0_0( + 544 => self.if_reset_statement_list0_0( &children[0], &children[1], &children[2], @@ -32465,23 +33584,23 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 538 => self.if_reset_statement_list0_list_0(&children[0], &children[1]), - 539 => self.if_reset_statement_list0_list_1(), - 540 => self.if_reset_statement_list0_1(), - 541 => self.if_reset_statement_list_0(&children[0], &children[1]), - 542 => self.if_reset_statement_list_1(), - 543 => self.if_reset_statement_opt_0( + 545 => self.if_reset_statement_list0_list_0(&children[0], &children[1]), + 546 => self.if_reset_statement_list0_list_1(), + 547 => self.if_reset_statement_list0_1(), + 548 => self.if_reset_statement_list_0(&children[0], &children[1]), + 549 => self.if_reset_statement_list_1(), + 550 => self.if_reset_statement_opt_0( &children[0], &children[1], &children[2], &children[3], ), - 544 => self.if_reset_statement_opt_list_0(&children[0], &children[1]), - 545 => self.if_reset_statement_opt_list_1(), - 546 => self.if_reset_statement_opt_1(), - 547 => self.return_statement(&children[0], &children[1], &children[2]), - 548 => self.break_statement(&children[0], &children[1]), - 549 => self.for_statement( + 551 => self.if_reset_statement_opt_list_0(&children[0], &children[1]), + 552 => self.if_reset_statement_opt_list_1(), + 553 => self.if_reset_statement_opt_1(), + 554 => self.return_statement(&children[0], &children[1], &children[2]), + 555 => self.break_statement(&children[0], &children[1]), + 556 => self.for_statement( &children[0], &children[1], &children[2], @@ -32493,45 +33612,45 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[8], &children[9], ), - 550 => self.for_statement_list_0(&children[0], &children[1]), - 551 => self.for_statement_list_1(), - 552 => self.for_statement_opt_0(&children[0], &children[1], &children[2]), - 553 => self.for_statement_opt_1(), - 554 => self.case_statement( + 557 => self.for_statement_list_0(&children[0], &children[1]), + 558 => self.for_statement_list_1(), + 559 => self.for_statement_opt_0(&children[0], &children[1], &children[2]), + 560 => self.for_statement_opt_1(), + 561 => self.case_statement( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 555 => self.case_statement_list_0(&children[0], &children[1]), - 556 => self.case_statement_list_1(), - 557 => self.case_item(&children[0], &children[1], &children[2]), - 558 => self.case_item_group0_0(&children[0]), - 559 => self.case_item_group0_1(&children[0], &children[1], &children[2]), - 560 => self.case_item_group0_list_0(&children[0], &children[1]), - 561 => self.case_item_group0_list_1(), - 562 => self.case_item_group_0(&children[0], &children[1]), - 563 => self.case_item_group_list_0(&children[0], &children[1], &children[2]), - 564 => self.case_item_group_list_1(), - 565 => self.case_item_group_1(&children[0]), - 566 => self.attribute( + 562 => self.case_statement_list_0(&children[0], &children[1]), + 563 => self.case_statement_list_1(), + 564 => self.case_item(&children[0], &children[1], &children[2]), + 565 => self.case_item_group0_0(&children[0]), + 566 => self.case_item_group0_1(&children[0], &children[1], &children[2]), + 567 => self.case_item_group0_list_0(&children[0], &children[1]), + 568 => self.case_item_group0_list_1(), + 569 => self.case_item_group_0(&children[0], &children[1]), + 570 => self.case_item_group_list_0(&children[0], &children[1], &children[2]), + 571 => self.case_item_group_list_1(), + 572 => self.case_item_group_1(&children[0]), + 573 => self.attribute( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 567 => self.attribute_opt_0(&children[0], &children[1], &children[2]), - 568 => self.attribute_opt_1(), - 569 => self.attribute_list(&children[0], &children[1], &children[2]), - 570 => self.attribute_list_list_0(&children[0], &children[1], &children[2]), - 571 => self.attribute_list_list_1(), - 572 => self.attribute_list_opt_0(&children[0]), - 573 => self.attribute_list_opt_1(), - 574 => self.attribute_item_0(&children[0]), - 575 => self.attribute_item_1(&children[0]), - 576 => self.let_declaration( + 574 => self.attribute_opt_0(&children[0], &children[1], &children[2]), + 575 => self.attribute_opt_1(), + 576 => self.attribute_list(&children[0], &children[1], &children[2]), + 577 => self.attribute_list_list_0(&children[0], &children[1], &children[2]), + 578 => self.attribute_list_list_1(), + 579 => self.attribute_list_opt_0(&children[0]), + 580 => self.attribute_list_opt_1(), + 581 => self.attribute_item_0(&children[0]), + 582 => self.attribute_item_1(&children[0]), + 583 => self.let_declaration( &children[0], &children[1], &children[2], @@ -32540,30 +33659,30 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 577 => self.var_declaration( + 584 => self.var_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 578 => self.local_declaration( + 585 => self.local_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 579 => self.local_declaration_group_0(&children[0], &children[1], &children[2]), - 580 => self.local_declaration_group_1(&children[0], &children[1], &children[2]), - 581 => self.type_def_declaration( + 586 => self.local_declaration_group_0(&children[0], &children[1], &children[2]), + 587 => self.local_declaration_group_1(&children[0], &children[1], &children[2]), + 588 => self.type_def_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 582 => self.always_ff_declaration( + 589 => self.always_ff_declaration( &children[0], &children[1], &children[2], @@ -32573,43 +33692,43 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[6], &children[7], ), - 583 => self.always_ff_declaration_list_0(&children[0], &children[1]), - 584 => self.always_ff_declaration_list_1(), - 585 => self.always_ff_declaration_opt_0(&children[0], &children[1]), - 586 => self.always_ff_declaration_opt_1(), - 587 => self.always_ff_clock(&children[0]), - 588 => self.always_ff_reset(&children[0]), - 589 => { + 590 => self.always_ff_declaration_list_0(&children[0], &children[1]), + 591 => self.always_ff_declaration_list_1(), + 592 => self.always_ff_declaration_opt_0(&children[0], &children[1]), + 593 => self.always_ff_declaration_opt_1(), + 594 => self.always_ff_clock(&children[0]), + 595 => self.always_ff_reset(&children[0]), + 596 => { self.always_comb_declaration(&children[0], &children[1], &children[2], &children[3]) } - 590 => self.always_comb_declaration_list_0(&children[0], &children[1]), - 591 => self.always_comb_declaration_list_1(), - 592 => self.assign_declaration( + 597 => self.always_comb_declaration_list_0(&children[0], &children[1]), + 598 => self.always_comb_declaration_list_1(), + 599 => self.assign_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 593 => self.modport_declaration( + 600 => self.modport_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 594 => self.modport_list(&children[0], &children[1], &children[2]), - 595 => self.modport_list_list_0(&children[0], &children[1], &children[2]), - 596 => self.modport_list_list_1(), - 597 => self.modport_list_opt_0(&children[0]), - 598 => self.modport_list_opt_1(), - 599 => self.modport_group(&children[0], &children[1]), - 600 => self.modport_group_group_0(&children[0], &children[1], &children[2]), - 601 => self.modport_group_group_1(&children[0]), - 602 => self.modport_group_list_0(&children[0], &children[1]), - 603 => self.modport_group_list_1(), - 604 => self.modport_item(&children[0], &children[1], &children[2]), - 605 => self.enum_declaration( + 601 => self.modport_list(&children[0], &children[1], &children[2]), + 602 => self.modport_list_list_0(&children[0], &children[1], &children[2]), + 603 => self.modport_list_list_1(), + 604 => self.modport_list_opt_0(&children[0]), + 605 => self.modport_list_opt_1(), + 606 => self.modport_group(&children[0], &children[1]), + 607 => self.modport_group_group_0(&children[0], &children[1], &children[2]), + 608 => self.modport_group_group_1(&children[0]), + 609 => self.modport_group_list_0(&children[0], &children[1]), + 610 => self.modport_group_list_1(), + 611 => self.modport_item(&children[0], &children[1], &children[2]), + 612 => self.enum_declaration( &children[0], &children[1], &children[2], @@ -32618,46 +33737,49 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 606 => self.enum_list(&children[0], &children[1], &children[2]), - 607 => self.enum_list_list_0(&children[0], &children[1], &children[2]), - 608 => self.enum_list_list_1(), - 609 => self.enum_list_opt_0(&children[0]), - 610 => self.enum_list_opt_1(), - 611 => self.enum_group(&children[0], &children[1]), - 612 => self.enum_group_group_0(&children[0], &children[1], &children[2]), - 613 => self.enum_group_group_1(&children[0]), - 614 => self.enum_group_list_0(&children[0], &children[1]), - 615 => self.enum_group_list_1(), - 616 => self.enum_item(&children[0], &children[1]), - 617 => self.enum_item_opt_0(&children[0], &children[1]), - 618 => self.enum_item_opt_1(), - 619 => self.struct_union_0(&children[0]), - 620 => self.struct_union_1(&children[0]), - 621 => self.struct_union_declaration( + 613 => self.enum_list(&children[0], &children[1], &children[2]), + 614 => self.enum_list_list_0(&children[0], &children[1], &children[2]), + 615 => self.enum_list_list_1(), + 616 => self.enum_list_opt_0(&children[0]), + 617 => self.enum_list_opt_1(), + 618 => self.enum_group(&children[0], &children[1]), + 619 => self.enum_group_group_0(&children[0], &children[1], &children[2]), + 620 => self.enum_group_group_1(&children[0]), + 621 => self.enum_group_list_0(&children[0], &children[1]), + 622 => self.enum_group_list_1(), + 623 => self.enum_item(&children[0], &children[1]), + 624 => self.enum_item_opt_0(&children[0], &children[1]), + 625 => self.enum_item_opt_1(), + 626 => self.struct_union_0(&children[0]), + 627 => self.struct_union_1(&children[0]), + 628 => self.struct_union_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], + &children[5], ), - 622 => self.struct_union_list(&children[0], &children[1], &children[2]), - 623 => self.struct_union_list_list_0(&children[0], &children[1], &children[2]), - 624 => self.struct_union_list_list_1(), - 625 => self.struct_union_list_opt_0(&children[0]), - 626 => self.struct_union_list_opt_1(), - 627 => self.struct_union_group(&children[0], &children[1]), - 628 => self.struct_union_group_group_0(&children[0], &children[1], &children[2]), - 629 => self.struct_union_group_group_1(&children[0]), - 630 => self.struct_union_group_list_0(&children[0], &children[1]), - 631 => self.struct_union_group_list_1(), - 632 => self.struct_union_item(&children[0], &children[1], &children[2]), - 633 => self.initial_declaration(&children[0], &children[1], &children[2], &children[3]), - 634 => self.initial_declaration_list_0(&children[0], &children[1]), - 635 => self.initial_declaration_list_1(), - 636 => self.final_declaration(&children[0], &children[1], &children[2], &children[3]), - 637 => self.final_declaration_list_0(&children[0], &children[1]), - 638 => self.final_declaration_list_1(), - 639 => self.inst_declaration( + 629 => self.struct_union_declaration_opt_0(&children[0]), + 630 => self.struct_union_declaration_opt_1(), + 631 => self.struct_union_list(&children[0], &children[1], &children[2]), + 632 => self.struct_union_list_list_0(&children[0], &children[1], &children[2]), + 633 => self.struct_union_list_list_1(), + 634 => self.struct_union_list_opt_0(&children[0]), + 635 => self.struct_union_list_opt_1(), + 636 => self.struct_union_group(&children[0], &children[1]), + 637 => self.struct_union_group_group_0(&children[0], &children[1], &children[2]), + 638 => self.struct_union_group_group_1(&children[0]), + 639 => self.struct_union_group_list_0(&children[0], &children[1]), + 640 => self.struct_union_group_list_1(), + 641 => self.struct_union_item(&children[0], &children[1], &children[2]), + 642 => self.initial_declaration(&children[0], &children[1], &children[2], &children[3]), + 643 => self.initial_declaration_list_0(&children[0], &children[1]), + 644 => self.initial_declaration_list_1(), + 645 => self.final_declaration(&children[0], &children[1], &children[2], &children[3]), + 646 => self.final_declaration_list_0(&children[0], &children[1]), + 647 => self.final_declaration_list_1(), + 648 => self.inst_declaration( &children[0], &children[1], &children[2], @@ -32667,85 +33789,102 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[6], &children[7], ), - 640 => self.inst_declaration_opt1_0(&children[0], &children[1], &children[2]), - 641 => self.inst_declaration_opt2_0(&children[0]), - 642 => self.inst_declaration_opt2_1(), - 643 => self.inst_declaration_opt1_1(), - 644 => self.inst_declaration_opt0_0(&children[0]), - 645 => self.inst_declaration_opt0_1(), - 646 => self.inst_declaration_opt_0(&children[0]), - 647 => self.inst_declaration_opt_1(), - 648 => self.inst_parameter(&children[0], &children[1], &children[2], &children[3]), - 649 => self.inst_parameter_opt_0(&children[0]), - 650 => self.inst_parameter_opt_1(), - 651 => self.inst_parameter_list(&children[0], &children[1], &children[2]), - 652 => self.inst_parameter_list_list_0(&children[0], &children[1], &children[2]), - 653 => self.inst_parameter_list_list_1(), - 654 => self.inst_parameter_list_opt_0(&children[0]), - 655 => self.inst_parameter_list_opt_1(), - 656 => self.inst_parameter_group(&children[0], &children[1]), - 657 => self.inst_parameter_group_group_0(&children[0], &children[1], &children[2]), - 658 => self.inst_parameter_group_group_1(&children[0]), - 659 => self.inst_parameter_group_list_0(&children[0], &children[1]), - 660 => self.inst_parameter_group_list_1(), - 661 => self.inst_parameter_item(&children[0], &children[1]), - 662 => self.inst_parameter_item_opt_0(&children[0], &children[1]), - 663 => self.inst_parameter_item_opt_1(), - 664 => self.inst_port_list(&children[0], &children[1], &children[2]), - 665 => self.inst_port_list_list_0(&children[0], &children[1], &children[2]), - 666 => self.inst_port_list_list_1(), - 667 => self.inst_port_list_opt_0(&children[0]), - 668 => self.inst_port_list_opt_1(), - 669 => self.inst_port_group(&children[0], &children[1]), - 670 => self.inst_port_group_group_0(&children[0], &children[1], &children[2]), - 671 => self.inst_port_group_group_1(&children[0]), - 672 => self.inst_port_group_list_0(&children[0], &children[1]), - 673 => self.inst_port_group_list_1(), - 674 => self.inst_port_item(&children[0], &children[1]), - 675 => self.inst_port_item_opt_0(&children[0], &children[1]), - 676 => self.inst_port_item_opt_1(), - 677 => self.with_parameter(&children[0], &children[1], &children[2], &children[3]), - 678 => self.with_parameter_opt_0(&children[0]), - 679 => self.with_parameter_opt_1(), - 680 => self.with_parameter_list(&children[0], &children[1], &children[2]), - 681 => self.with_parameter_list_list_0(&children[0], &children[1], &children[2]), - 682 => self.with_parameter_list_list_1(), - 683 => self.with_parameter_list_opt_0(&children[0]), - 684 => self.with_parameter_list_opt_1(), - 685 => self.with_parameter_group(&children[0], &children[1]), - 686 => self.with_parameter_group_group_0(&children[0], &children[1], &children[2]), - 687 => self.with_parameter_group_group_1(&children[0]), - 688 => self.with_parameter_group_list_0(&children[0], &children[1]), - 689 => self.with_parameter_group_list_1(), - 690 => self.with_parameter_item(&children[0], &children[1], &children[2], &children[3]), - 691 => self.with_parameter_item_group0_0(&children[0], &children[1], &children[2]), - 692 => self.with_parameter_item_group0_1(&children[0], &children[1], &children[2]), - 693 => self.with_parameter_item_group_0(&children[0]), - 694 => self.with_parameter_item_group_1(&children[0]), - 695 => self.port_declaration(&children[0], &children[1], &children[2]), - 696 => self.port_declaration_opt_0(&children[0]), - 697 => self.port_declaration_opt_1(), - 698 => self.port_declaration_list(&children[0], &children[1], &children[2]), - 699 => self.port_declaration_list_list_0(&children[0], &children[1], &children[2]), - 700 => self.port_declaration_list_list_1(), - 701 => self.port_declaration_list_opt_0(&children[0]), - 702 => self.port_declaration_list_opt_1(), - 703 => self.port_declaration_group(&children[0], &children[1]), - 704 => self.port_declaration_group_group_0(&children[0], &children[1], &children[2]), - 705 => self.port_declaration_group_group_1(&children[0]), - 706 => self.port_declaration_group_list_0(&children[0], &children[1]), - 707 => self.port_declaration_group_list_1(), - 708 => self.port_declaration_item(&children[0], &children[1], &children[2]), - 709 => self.port_declaration_item_group_0(&children[0], &children[1]), - 710 => self.port_declaration_item_group_1(&children[0], &children[1]), - 711 => self.port_declaration_item_opt_0(&children[0]), - 712 => self.port_declaration_item_opt_1(), - 713 => self.direction_0(&children[0]), - 714 => self.direction_1(&children[0]), - 715 => self.direction_2(&children[0]), - 716 => self.direction_3(&children[0]), - 717 => self.direction_4(&children[0]), - 718 => self.function_declaration( + 649 => self.inst_declaration_opt1_0(&children[0], &children[1], &children[2]), + 650 => self.inst_declaration_opt2_0(&children[0]), + 651 => self.inst_declaration_opt2_1(), + 652 => self.inst_declaration_opt1_1(), + 653 => self.inst_declaration_opt0_0(&children[0]), + 654 => self.inst_declaration_opt0_1(), + 655 => self.inst_declaration_opt_0(&children[0]), + 656 => self.inst_declaration_opt_1(), + 657 => self.inst_parameter(&children[0], &children[1], &children[2], &children[3]), + 658 => self.inst_parameter_opt_0(&children[0]), + 659 => self.inst_parameter_opt_1(), + 660 => self.inst_parameter_list(&children[0], &children[1], &children[2]), + 661 => self.inst_parameter_list_list_0(&children[0], &children[1], &children[2]), + 662 => self.inst_parameter_list_list_1(), + 663 => self.inst_parameter_list_opt_0(&children[0]), + 664 => self.inst_parameter_list_opt_1(), + 665 => self.inst_parameter_group(&children[0], &children[1]), + 666 => self.inst_parameter_group_group_0(&children[0], &children[1], &children[2]), + 667 => self.inst_parameter_group_group_1(&children[0]), + 668 => self.inst_parameter_group_list_0(&children[0], &children[1]), + 669 => self.inst_parameter_group_list_1(), + 670 => self.inst_parameter_item(&children[0], &children[1]), + 671 => self.inst_parameter_item_opt_0(&children[0], &children[1]), + 672 => self.inst_parameter_item_opt_1(), + 673 => self.inst_port_list(&children[0], &children[1], &children[2]), + 674 => self.inst_port_list_list_0(&children[0], &children[1], &children[2]), + 675 => self.inst_port_list_list_1(), + 676 => self.inst_port_list_opt_0(&children[0]), + 677 => self.inst_port_list_opt_1(), + 678 => self.inst_port_group(&children[0], &children[1]), + 679 => self.inst_port_group_group_0(&children[0], &children[1], &children[2]), + 680 => self.inst_port_group_group_1(&children[0]), + 681 => self.inst_port_group_list_0(&children[0], &children[1]), + 682 => self.inst_port_group_list_1(), + 683 => self.inst_port_item(&children[0], &children[1]), + 684 => self.inst_port_item_opt_0(&children[0], &children[1]), + 685 => self.inst_port_item_opt_1(), + 686 => self.with_parameter(&children[0], &children[1], &children[2], &children[3]), + 687 => self.with_parameter_opt_0(&children[0]), + 688 => self.with_parameter_opt_1(), + 689 => self.with_parameter_list(&children[0], &children[1], &children[2]), + 690 => self.with_parameter_list_list_0(&children[0], &children[1], &children[2]), + 691 => self.with_parameter_list_list_1(), + 692 => self.with_parameter_list_opt_0(&children[0]), + 693 => self.with_parameter_list_opt_1(), + 694 => self.with_parameter_group(&children[0], &children[1]), + 695 => self.with_parameter_group_group_0(&children[0], &children[1], &children[2]), + 696 => self.with_parameter_group_group_1(&children[0]), + 697 => self.with_parameter_group_list_0(&children[0], &children[1]), + 698 => self.with_parameter_group_list_1(), + 699 => self.with_parameter_item(&children[0], &children[1], &children[2], &children[3]), + 700 => self.with_parameter_item_group0_0(&children[0], &children[1], &children[2]), + 701 => self.with_parameter_item_group0_1(&children[0], &children[1], &children[2]), + 702 => self.with_parameter_item_group_0(&children[0]), + 703 => self.with_parameter_item_group_1(&children[0]), + 704 => self.with_generic_parameter(&children[0], &children[1], &children[2]), + 705 => self.with_generic_parameter_list(&children[0], &children[1], &children[2]), + 706 => { + self.with_generic_parameter_list_list_0(&children[0], &children[1], &children[2]) + } + 707 => self.with_generic_parameter_list_list_1(), + 708 => self.with_generic_parameter_list_opt_0(&children[0]), + 709 => self.with_generic_parameter_list_opt_1(), + 710 => self.with_generic_parameter_item(&children[0]), + 711 => self.with_generic_argument(&children[0], &children[1], &children[2]), + 712 => self.with_generic_argument_list(&children[0], &children[1], &children[2]), + 713 => self.with_generic_argument_list_list_0(&children[0], &children[1], &children[2]), + 714 => self.with_generic_argument_list_list_1(), + 715 => self.with_generic_argument_list_opt_0(&children[0]), + 716 => self.with_generic_argument_list_opt_1(), + 717 => self.with_generic_argument_item_0(&children[0]), + 718 => self.with_generic_argument_item_1(&children[0]), + 719 => self.port_declaration(&children[0], &children[1], &children[2]), + 720 => self.port_declaration_opt_0(&children[0]), + 721 => self.port_declaration_opt_1(), + 722 => self.port_declaration_list(&children[0], &children[1], &children[2]), + 723 => self.port_declaration_list_list_0(&children[0], &children[1], &children[2]), + 724 => self.port_declaration_list_list_1(), + 725 => self.port_declaration_list_opt_0(&children[0]), + 726 => self.port_declaration_list_opt_1(), + 727 => self.port_declaration_group(&children[0], &children[1]), + 728 => self.port_declaration_group_group_0(&children[0], &children[1], &children[2]), + 729 => self.port_declaration_group_group_1(&children[0]), + 730 => self.port_declaration_group_list_0(&children[0], &children[1]), + 731 => self.port_declaration_group_list_1(), + 732 => self.port_declaration_item(&children[0], &children[1], &children[2]), + 733 => self.port_declaration_item_group_0(&children[0], &children[1]), + 734 => self.port_declaration_item_group_1(&children[0], &children[1]), + 735 => self.port_declaration_item_opt_0(&children[0]), + 736 => self.port_declaration_item_opt_1(), + 737 => self.direction_0(&children[0]), + 738 => self.direction_1(&children[0]), + 739 => self.direction_2(&children[0]), + 740 => self.direction_3(&children[0]), + 741 => self.direction_4(&children[0]), + 742 => self.function_declaration( &children[0], &children[1], &children[2], @@ -32753,24 +33892,27 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], &children[6], + &children[7], ), - 719 => self.function_declaration_list_0(&children[0], &children[1]), - 720 => self.function_declaration_list_1(), - 721 => self.function_declaration_opt0_0(&children[0], &children[1]), - 722 => self.function_declaration_opt0_1(), - 723 => self.function_declaration_opt_0(&children[0]), - 724 => self.function_declaration_opt_1(), - 725 => self.function_item_0(&children[0]), - 726 => self.function_item_1(&children[0]), - 727 => self.import_declaration(&children[0], &children[1], &children[2], &children[3]), - 728 => self.import_declaration_opt_0(&children[0], &children[1]), - 729 => self.import_declaration_opt_1(), - 730 => self.export_declaration(&children[0], &children[1], &children[2]), - 731 => self.export_declaration_group_0(&children[0]), - 732 => self.export_declaration_group_1(&children[0], &children[1]), - 733 => self.export_declaration_opt_0(&children[0], &children[1]), - 734 => self.export_declaration_opt_1(), - 735 => self.module_declaration( + 743 => self.function_declaration_list_0(&children[0], &children[1]), + 744 => self.function_declaration_list_1(), + 745 => self.function_declaration_opt1_0(&children[0], &children[1]), + 746 => self.function_declaration_opt1_1(), + 747 => self.function_declaration_opt0_0(&children[0]), + 748 => self.function_declaration_opt0_1(), + 749 => self.function_declaration_opt_0(&children[0]), + 750 => self.function_declaration_opt_1(), + 751 => self.function_item_0(&children[0]), + 752 => self.function_item_1(&children[0]), + 753 => self.import_declaration(&children[0], &children[1], &children[2], &children[3]), + 754 => self.import_declaration_opt_0(&children[0], &children[1]), + 755 => self.import_declaration_opt_1(), + 756 => self.export_declaration(&children[0], &children[1], &children[2]), + 757 => self.export_declaration_group_0(&children[0]), + 758 => self.export_declaration_group_1(&children[0], &children[1]), + 759 => self.export_declaration_opt_0(&children[0], &children[1]), + 760 => self.export_declaration_opt_1(), + 761 => self.module_declaration( &children[0], &children[1], &children[2], @@ -32779,33 +33921,36 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], &children[7], + &children[8], ), - 736 => self.module_declaration_list_0(&children[0], &children[1]), - 737 => self.module_declaration_list_1(), - 738 => self.module_declaration_opt1_0(&children[0]), - 739 => self.module_declaration_opt1_1(), - 740 => self.module_declaration_opt0_0(&children[0]), - 741 => self.module_declaration_opt0_1(), - 742 => self.module_declaration_opt_0(&children[0]), - 743 => self.module_declaration_opt_1(), - 744 => self.module_if_declaration( + 762 => self.module_declaration_list_0(&children[0], &children[1]), + 763 => self.module_declaration_list_1(), + 764 => self.module_declaration_opt2_0(&children[0]), + 765 => self.module_declaration_opt2_1(), + 766 => self.module_declaration_opt1_0(&children[0]), + 767 => self.module_declaration_opt1_1(), + 768 => self.module_declaration_opt0_0(&children[0]), + 769 => self.module_declaration_opt0_1(), + 770 => self.module_declaration_opt_0(&children[0]), + 771 => self.module_declaration_opt_1(), + 772 => self.module_if_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 745 => self.module_if_declaration_list_0( + 773 => self.module_if_declaration_list_0( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 746 => self.module_if_declaration_list_1(), - 747 => self.module_if_declaration_opt_0(&children[0], &children[1]), - 748 => self.module_if_declaration_opt_1(), - 749 => self.module_for_declaration( + 774 => self.module_if_declaration_list_1(), + 775 => self.module_if_declaration_opt_0(&children[0], &children[1]), + 776 => self.module_if_declaration_opt_1(), + 777 => self.module_for_declaration( &children[0], &children[1], &children[2], @@ -32813,52 +33958,52 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 750 => self.module_for_declaration_opt_0(&children[0], &children[1], &children[2]), - 751 => self.module_for_declaration_opt_1(), - 752 => self.module_named_block( + 778 => self.module_for_declaration_opt_0(&children[0], &children[1], &children[2]), + 779 => self.module_for_declaration_opt_1(), + 780 => self.module_named_block( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 753 => self.module_named_block_list_0(&children[0], &children[1]), - 754 => self.module_named_block_list_1(), - 755 => self.module_optional_named_block( + 781 => self.module_named_block_list_0(&children[0], &children[1]), + 782 => self.module_named_block_list_1(), + 783 => self.module_optional_named_block( &children[0], &children[1], &children[2], &children[3], ), - 756 => self.module_optional_named_block_list_0(&children[0], &children[1]), - 757 => self.module_optional_named_block_list_1(), - 758 => self.module_optional_named_block_opt_0(&children[0], &children[1]), - 759 => self.module_optional_named_block_opt_1(), - 760 => self.module_group(&children[0], &children[1]), - 761 => self.module_group_group_0(&children[0], &children[1], &children[2]), - 762 => self.module_group_group_list_0(&children[0], &children[1]), - 763 => self.module_group_group_list_1(), - 764 => self.module_group_group_1(&children[0]), - 765 => self.module_group_list_0(&children[0], &children[1]), - 766 => self.module_group_list_1(), - 767 => self.module_item_0(&children[0]), - 768 => self.module_item_1(&children[0]), - 769 => self.module_item_2(&children[0]), - 770 => self.module_item_3(&children[0]), - 771 => self.module_item_4(&children[0]), - 772 => self.module_item_5(&children[0]), - 773 => self.module_item_6(&children[0]), - 774 => self.module_item_7(&children[0]), - 775 => self.module_item_8(&children[0]), - 776 => self.module_item_9(&children[0]), - 777 => self.module_item_10(&children[0]), - 778 => self.module_item_11(&children[0]), - 779 => self.module_item_12(&children[0]), - 780 => self.module_item_13(&children[0]), - 781 => self.module_item_14(&children[0]), - 782 => self.module_item_15(&children[0]), - 783 => self.module_item_16(&children[0]), - 784 => self.interface_declaration( + 784 => self.module_optional_named_block_list_0(&children[0], &children[1]), + 785 => self.module_optional_named_block_list_1(), + 786 => self.module_optional_named_block_opt_0(&children[0], &children[1]), + 787 => self.module_optional_named_block_opt_1(), + 788 => self.module_group(&children[0], &children[1]), + 789 => self.module_group_group_0(&children[0], &children[1], &children[2]), + 790 => self.module_group_group_list_0(&children[0], &children[1]), + 791 => self.module_group_group_list_1(), + 792 => self.module_group_group_1(&children[0]), + 793 => self.module_group_list_0(&children[0], &children[1]), + 794 => self.module_group_list_1(), + 795 => self.module_item_0(&children[0]), + 796 => self.module_item_1(&children[0]), + 797 => self.module_item_2(&children[0]), + 798 => self.module_item_3(&children[0]), + 799 => self.module_item_4(&children[0]), + 800 => self.module_item_5(&children[0]), + 801 => self.module_item_6(&children[0]), + 802 => self.module_item_7(&children[0]), + 803 => self.module_item_8(&children[0]), + 804 => self.module_item_9(&children[0]), + 805 => self.module_item_10(&children[0]), + 806 => self.module_item_11(&children[0]), + 807 => self.module_item_12(&children[0]), + 808 => self.module_item_13(&children[0]), + 809 => self.module_item_14(&children[0]), + 810 => self.module_item_15(&children[0]), + 811 => self.module_item_16(&children[0]), + 812 => self.interface_declaration( &children[0], &children[1], &children[2], @@ -32866,31 +34011,34 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], &children[6], + &children[7], ), - 785 => self.interface_declaration_list_0(&children[0], &children[1]), - 786 => self.interface_declaration_list_1(), - 787 => self.interface_declaration_opt0_0(&children[0]), - 788 => self.interface_declaration_opt0_1(), - 789 => self.interface_declaration_opt_0(&children[0]), - 790 => self.interface_declaration_opt_1(), - 791 => self.interface_if_declaration( + 813 => self.interface_declaration_list_0(&children[0], &children[1]), + 814 => self.interface_declaration_list_1(), + 815 => self.interface_declaration_opt1_0(&children[0]), + 816 => self.interface_declaration_opt1_1(), + 817 => self.interface_declaration_opt0_0(&children[0]), + 818 => self.interface_declaration_opt0_1(), + 819 => self.interface_declaration_opt_0(&children[0]), + 820 => self.interface_declaration_opt_1(), + 821 => self.interface_if_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 792 => self.interface_if_declaration_list_0( + 822 => self.interface_if_declaration_list_0( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 793 => self.interface_if_declaration_list_1(), - 794 => self.interface_if_declaration_opt_0(&children[0], &children[1]), - 795 => self.interface_if_declaration_opt_1(), - 796 => self.interface_for_declaration( + 823 => self.interface_if_declaration_list_1(), + 824 => self.interface_if_declaration_opt_0(&children[0], &children[1]), + 825 => self.interface_if_declaration_opt_1(), + 826 => self.interface_for_declaration( &children[0], &children[1], &children[2], @@ -32898,78 +34046,81 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 797 => self.interface_for_declaration_opt_0(&children[0], &children[1], &children[2]), - 798 => self.interface_for_declaration_opt_1(), - 799 => self.interface_named_block( + 827 => self.interface_for_declaration_opt_0(&children[0], &children[1], &children[2]), + 828 => self.interface_for_declaration_opt_1(), + 829 => self.interface_named_block( &children[0], &children[1], &children[2], &children[3], &children[4], ), - 800 => self.interface_named_block_list_0(&children[0], &children[1]), - 801 => self.interface_named_block_list_1(), - 802 => self.interface_optional_named_block( + 830 => self.interface_named_block_list_0(&children[0], &children[1]), + 831 => self.interface_named_block_list_1(), + 832 => self.interface_optional_named_block( &children[0], &children[1], &children[2], &children[3], ), - 803 => self.interface_optional_named_block_list_0(&children[0], &children[1]), - 804 => self.interface_optional_named_block_list_1(), - 805 => self.interface_optional_named_block_opt_0(&children[0], &children[1]), - 806 => self.interface_optional_named_block_opt_1(), - 807 => self.interface_group(&children[0], &children[1]), - 808 => self.interface_group_group_0(&children[0], &children[1], &children[2]), - 809 => self.interface_group_group_list_0(&children[0], &children[1]), - 810 => self.interface_group_group_list_1(), - 811 => self.interface_group_group_1(&children[0]), - 812 => self.interface_group_list_0(&children[0], &children[1]), - 813 => self.interface_group_list_1(), - 814 => self.interface_item_0(&children[0]), - 815 => self.interface_item_1(&children[0]), - 816 => self.interface_item_2(&children[0]), - 817 => self.interface_item_3(&children[0]), - 818 => self.interface_item_4(&children[0]), - 819 => self.interface_item_5(&children[0]), - 820 => self.interface_item_6(&children[0]), - 821 => self.interface_item_7(&children[0]), - 822 => self.interface_item_8(&children[0]), - 823 => self.interface_item_9(&children[0]), - 824 => self.interface_item_10(&children[0]), - 825 => self.interface_item_11(&children[0]), - 826 => self.interface_item_12(&children[0]), - 827 => self.interface_item_13(&children[0]), - 828 => self.package_declaration( + 833 => self.interface_optional_named_block_list_0(&children[0], &children[1]), + 834 => self.interface_optional_named_block_list_1(), + 835 => self.interface_optional_named_block_opt_0(&children[0], &children[1]), + 836 => self.interface_optional_named_block_opt_1(), + 837 => self.interface_group(&children[0], &children[1]), + 838 => self.interface_group_group_0(&children[0], &children[1], &children[2]), + 839 => self.interface_group_group_list_0(&children[0], &children[1]), + 840 => self.interface_group_group_list_1(), + 841 => self.interface_group_group_1(&children[0]), + 842 => self.interface_group_list_0(&children[0], &children[1]), + 843 => self.interface_group_list_1(), + 844 => self.interface_item_0(&children[0]), + 845 => self.interface_item_1(&children[0]), + 846 => self.interface_item_2(&children[0]), + 847 => self.interface_item_3(&children[0]), + 848 => self.interface_item_4(&children[0]), + 849 => self.interface_item_5(&children[0]), + 850 => self.interface_item_6(&children[0]), + 851 => self.interface_item_7(&children[0]), + 852 => self.interface_item_8(&children[0]), + 853 => self.interface_item_9(&children[0]), + 854 => self.interface_item_10(&children[0]), + 855 => self.interface_item_11(&children[0]), + 856 => self.interface_item_12(&children[0]), + 857 => self.interface_item_13(&children[0]), + 858 => self.package_declaration( &children[0], &children[1], &children[2], &children[3], &children[4], &children[5], + &children[6], ), - 829 => self.package_declaration_list_0(&children[0], &children[1]), - 830 => self.package_declaration_list_1(), - 831 => self.package_declaration_opt_0(&children[0]), - 832 => self.package_declaration_opt_1(), - 833 => self.package_group(&children[0], &children[1]), - 834 => self.package_group_group_0(&children[0], &children[1], &children[2]), - 835 => self.package_group_group_list_0(&children[0], &children[1]), - 836 => self.package_group_group_list_1(), - 837 => self.package_group_group_1(&children[0]), - 838 => self.package_group_list_0(&children[0], &children[1]), - 839 => self.package_group_list_1(), - 840 => self.package_item_0(&children[0]), - 841 => self.package_item_1(&children[0]), - 842 => self.package_item_2(&children[0]), - 843 => self.package_item_3(&children[0]), - 844 => self.package_item_4(&children[0]), - 845 => self.package_item_5(&children[0]), - 846 => self.package_item_6(&children[0]), - 847 => self.package_item_7(&children[0]), - 848 => self.package_item_8(&children[0]), - 849 => self.package_item_9(&children[0]), - 850 => self.embed_declaration( + 859 => self.package_declaration_list_0(&children[0], &children[1]), + 860 => self.package_declaration_list_1(), + 861 => self.package_declaration_opt0_0(&children[0]), + 862 => self.package_declaration_opt0_1(), + 863 => self.package_declaration_opt_0(&children[0]), + 864 => self.package_declaration_opt_1(), + 865 => self.package_group(&children[0], &children[1]), + 866 => self.package_group_group_0(&children[0], &children[1], &children[2]), + 867 => self.package_group_group_list_0(&children[0], &children[1]), + 868 => self.package_group_group_list_1(), + 869 => self.package_group_group_1(&children[0]), + 870 => self.package_group_list_0(&children[0], &children[1]), + 871 => self.package_group_list_1(), + 872 => self.package_item_0(&children[0]), + 873 => self.package_item_1(&children[0]), + 874 => self.package_item_2(&children[0]), + 875 => self.package_item_3(&children[0]), + 876 => self.package_item_4(&children[0]), + 877 => self.package_item_5(&children[0]), + 878 => self.package_item_6(&children[0]), + 879 => self.package_item_7(&children[0]), + 880 => self.package_item_8(&children[0]), + 881 => self.package_item_9(&children[0]), + 882 => self.embed_declaration( &children[0], &children[1], &children[2], @@ -32977,8 +34128,8 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[4], &children[5], ), - 851 => self.embed_content(&children[0]), - 852 => self.embed_content_token( + 883 => self.embed_content(&children[0]), + 884 => self.embed_content_token( &children[0], &children[1], &children[2], @@ -32987,13 +34138,13 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 853 => self.embed_content_token_list_0(&children[0], &children[1]), - 854 => self.embed_content_token_list_1(), - 855 => self.embed_item_0(&children[0], &children[1], &children[2]), - 856 => self.embed_item_list_0(&children[0], &children[1]), - 857 => self.embed_item_list_1(), - 858 => self.embed_item_1(&children[0]), - 859 => self.include_declaration( + 885 => self.embed_content_token_list_0(&children[0], &children[1]), + 886 => self.embed_content_token_list_1(), + 887 => self.embed_item_0(&children[0], &children[1], &children[2]), + 888 => self.embed_item_list_0(&children[0], &children[1]), + 889 => self.embed_item_list_1(), + 890 => self.embed_item_1(&children[0]), + 891 => self.include_declaration( &children[0], &children[1], &children[2], @@ -33002,22 +34153,22 @@ impl<'t> UserActionsTrait<'t> for VerylGrammarAuto<'t, '_> { &children[5], &children[6], ), - 860 => self.description_group(&children[0], &children[1]), - 861 => self.description_group_group_0(&children[0], &children[1], &children[2]), - 862 => self.description_group_group_list_0(&children[0], &children[1]), - 863 => self.description_group_group_list_1(), - 864 => self.description_group_group_1(&children[0]), - 865 => self.description_group_list_0(&children[0], &children[1]), - 866 => self.description_group_list_1(), - 867 => self.description_item_0(&children[0]), - 868 => self.description_item_1(&children[0]), - 869 => self.description_item_2(&children[0]), - 870 => self.description_item_3(&children[0]), - 871 => self.description_item_4(&children[0]), - 872 => self.description_item_5(&children[0]), - 873 => self.veryl(&children[0], &children[1]), - 874 => self.veryl_list_0(&children[0], &children[1]), - 875 => self.veryl_list_1(), + 892 => self.description_group(&children[0], &children[1]), + 893 => self.description_group_group_0(&children[0], &children[1], &children[2]), + 894 => self.description_group_group_list_0(&children[0], &children[1]), + 895 => self.description_group_group_list_1(), + 896 => self.description_group_group_1(&children[0]), + 897 => self.description_group_list_0(&children[0], &children[1]), + 898 => self.description_group_list_1(), + 899 => self.description_item_0(&children[0]), + 900 => self.description_item_1(&children[0]), + 901 => self.description_item_2(&children[0]), + 902 => self.description_item_3(&children[0]), + 903 => self.description_item_4(&children[0]), + 904 => self.description_item_5(&children[0]), + 905 => self.veryl(&children[0], &children[1]), + 906 => self.veryl_list_0(&children[0], &children[1]), + 907 => self.veryl_list_1(), _ => Err(ParserError::InternalError(format!( "Unhandled production number: {}", prod_num diff --git a/crates/parser/src/generated/veryl_parser.rs b/crates/parser/src/generated/veryl_parser.rs index 425b6f34..beb9dc56 100644 --- a/crates/parser/src/generated/veryl_parser.rs +++ b/crates/parser/src/generated/veryl_parser.rs @@ -18,7 +18,7 @@ use parol_runtime::lexer::tokenizer::{ ERROR_TOKEN, NEW_LINE_TOKEN, UNMATCHABLE_TOKEN, WHITESPACE_TOKEN, }; -pub const TERMINALS: &[&str; 114] = &[ +pub const TERMINALS: &[&str; 115] = &[ /* 0 */ UNMATCHABLE_TOKEN, /* 1 */ UNMATCHABLE_TOKEN, /* 2 */ UNMATCHABLE_TOKEN, @@ -48,95 +48,96 @@ pub const TERMINALS: &[&str; 114] = &[ /* 25 */ r"\^~|\^|~\^", /* 26 */ r"\|", /* 27 */ r"~&|~\||!|~", - /* 28 */ r"::", - /* 29 */ r":", - /* 30 */ r",", - /* 31 */ r"\.\.=", - /* 32 */ r"\.\.", - /* 33 */ r"\.", - /* 34 */ r"=", - /* 35 */ r"\#", - /* 36 */ r"<", - /* 37 */ r"'\{", - /* 38 */ r"\{", - /* 39 */ r"\[", - /* 40 */ r"\(", - /* 41 */ r">", - /* 42 */ r"\}", - /* 43 */ r"\]", - /* 44 */ r"\)", - /* 45 */ r";", - /* 46 */ r"\*", - /* 47 */ r"(?-u:\b)always_comb(?-u:\b)", - /* 48 */ r"(?-u:\b)always_ff(?-u:\b)", - /* 49 */ r"(?-u:\b)assign(?-u:\b)", - /* 50 */ r"(?-u:\b)as(?-u:\b)", - /* 51 */ r"(?-u:\b)bit(?-u:\b)", - /* 52 */ r"(?-u:\b)case(?-u:\b)", - /* 53 */ r"(?-u:\b)clock(?-u:\b)", - /* 54 */ r"(?-u:\b)clock_posedge(?-u:\b)", - /* 55 */ r"(?-u:\b)clock_negedge(?-u:\b)", - /* 56 */ r"(?-u:\b)default(?-u:\b)", - /* 57 */ r"(?-u:\b)else(?-u:\b)", - /* 58 */ r"(?-u:\b)embed(?-u:\b)", - /* 59 */ r"(?-u:\b)enum(?-u:\b)", - /* 60 */ r"(?-u:\b)export(?-u:\b)", - /* 61 */ r"(?-u:\b)f32(?-u:\b)", - /* 62 */ r"(?-u:\b)f64(?-u:\b)", - /* 63 */ r"(?-u:\b)final(?-u:\b)", - /* 64 */ r"(?-u:\b)for(?-u:\b)", - /* 65 */ r"(?-u:\b)function(?-u:\b)", - /* 66 */ r"(?-u:\b)i32(?-u:\b)", - /* 67 */ r"(?-u:\b)i64(?-u:\b)", - /* 68 */ r"(?-u:\b)if_reset(?-u:\b)", - /* 69 */ r"(?-u:\b)if(?-u:\b)", - /* 70 */ r"(?-u:\b)import(?-u:\b)", - /* 71 */ r"(?-u:\b)include(?-u:\b)", - /* 72 */ r"(?-u:\b)initial(?-u:\b)", - /* 73 */ r"(?-u:\b)inout(?-u:\b)", - /* 74 */ r"(?-u:\b)input(?-u:\b)", - /* 75 */ r"(?-u:\b)inside(?-u:\b)", - /* 76 */ r"(?-u:\b)inst(?-u:\b)", - /* 77 */ r"(?-u:\b)interface(?-u:\b)", - /* 78 */ r"(?-u:\b)in(?-u:\b)", - /* 79 */ r"(?-u:\b)let(?-u:\b)", - /* 80 */ r"(?-u:\b)local(?-u:\b)", - /* 81 */ r"(?-u:\b)logic(?-u:\b)", - /* 82 */ r"(?-u:\b)lsb(?-u:\b)", - /* 83 */ r"(?-u:\b)modport(?-u:\b)", - /* 84 */ r"(?-u:\b)module(?-u:\b)", - /* 85 */ r"(?-u:\b)msb(?-u:\b)", - /* 86 */ r"(?-u:\b)output(?-u:\b)", - /* 87 */ r"(?-u:\b)outside(?-u:\b)", - /* 88 */ r"(?-u:\b)package(?-u:\b)", - /* 89 */ r"(?-u:\b)param(?-u:\b)", - /* 90 */ r"(?-u:\b)pub(?-u:\b)", - /* 91 */ r"(?-u:\b)ref(?-u:\b)", - /* 92 */ r"(?-u:\b)repeat(?-u:\b)", - /* 93 */ r"(?-u:\b)reset(?-u:\b)", - /* 94 */ r"(?-u:\b)reset_async_high(?-u:\b)", - /* 95 */ r"(?-u:\b)reset_async_low(?-u:\b)", - /* 96 */ r"(?-u:\b)reset_sync_high(?-u:\b)", - /* 97 */ r"(?-u:\b)reset_sync_low(?-u:\b)", - /* 98 */ r"(?-u:\b)return(?-u:\b)", - /* 99 */ r"(?-u:\b)break(?-u:\b)", - /* 100 */ r"(?-u:\b)signed(?-u:\b)", - /* 101 */ r"(?-u:\b)step(?-u:\b)", - /* 102 */ r"(?-u:\b)string(?-u:\b)", - /* 103 */ r"(?-u:\b)struct(?-u:\b)", - /* 104 */ r"(?-u:\b)tri(?-u:\b)", - /* 105 */ r"(?-u:\b)type(?-u:\b)", - /* 106 */ r"(?-u:\b)u32(?-u:\b)", - /* 107 */ r"(?-u:\b)u64(?-u:\b)", - /* 108 */ r"(?-u:\b)union(?-u:\b)", - /* 109 */ r"(?-u:\b)var(?-u:\b)", - /* 110 */ r"\$[a-zA-Z_][0-9a-zA-Z_$]*", - /* 111 */ r"[a-zA-Z_][0-9a-zA-Z_$]*", - /* 112 */ r"[^{}]*", - /* 113 */ ERROR_TOKEN, + /* 28 */ r"::<", + /* 29 */ r"::", + /* 30 */ r":", + /* 31 */ r",", + /* 32 */ r"\.\.=", + /* 33 */ r"\.\.", + /* 34 */ r"\.", + /* 35 */ r"=", + /* 36 */ r"\#", + /* 37 */ r"<", + /* 38 */ r"'\{", + /* 39 */ r"\{", + /* 40 */ r"\[", + /* 41 */ r"\(", + /* 42 */ r">", + /* 43 */ r"\}", + /* 44 */ r"\]", + /* 45 */ r"\)", + /* 46 */ r";", + /* 47 */ r"\*", + /* 48 */ r"(?-u:\b)always_comb(?-u:\b)", + /* 49 */ r"(?-u:\b)always_ff(?-u:\b)", + /* 50 */ r"(?-u:\b)assign(?-u:\b)", + /* 51 */ r"(?-u:\b)as(?-u:\b)", + /* 52 */ r"(?-u:\b)bit(?-u:\b)", + /* 53 */ r"(?-u:\b)case(?-u:\b)", + /* 54 */ r"(?-u:\b)clock(?-u:\b)", + /* 55 */ r"(?-u:\b)clock_posedge(?-u:\b)", + /* 56 */ r"(?-u:\b)clock_negedge(?-u:\b)", + /* 57 */ r"(?-u:\b)default(?-u:\b)", + /* 58 */ r"(?-u:\b)else(?-u:\b)", + /* 59 */ r"(?-u:\b)embed(?-u:\b)", + /* 60 */ r"(?-u:\b)enum(?-u:\b)", + /* 61 */ r"(?-u:\b)export(?-u:\b)", + /* 62 */ r"(?-u:\b)f32(?-u:\b)", + /* 63 */ r"(?-u:\b)f64(?-u:\b)", + /* 64 */ r"(?-u:\b)final(?-u:\b)", + /* 65 */ r"(?-u:\b)for(?-u:\b)", + /* 66 */ r"(?-u:\b)function(?-u:\b)", + /* 67 */ r"(?-u:\b)i32(?-u:\b)", + /* 68 */ r"(?-u:\b)i64(?-u:\b)", + /* 69 */ r"(?-u:\b)if_reset(?-u:\b)", + /* 70 */ r"(?-u:\b)if(?-u:\b)", + /* 71 */ r"(?-u:\b)import(?-u:\b)", + /* 72 */ r"(?-u:\b)include(?-u:\b)", + /* 73 */ r"(?-u:\b)initial(?-u:\b)", + /* 74 */ r"(?-u:\b)inout(?-u:\b)", + /* 75 */ r"(?-u:\b)input(?-u:\b)", + /* 76 */ r"(?-u:\b)inside(?-u:\b)", + /* 77 */ r"(?-u:\b)inst(?-u:\b)", + /* 78 */ r"(?-u:\b)interface(?-u:\b)", + /* 79 */ r"(?-u:\b)in(?-u:\b)", + /* 80 */ r"(?-u:\b)let(?-u:\b)", + /* 81 */ r"(?-u:\b)local(?-u:\b)", + /* 82 */ r"(?-u:\b)logic(?-u:\b)", + /* 83 */ r"(?-u:\b)lsb(?-u:\b)", + /* 84 */ r"(?-u:\b)modport(?-u:\b)", + /* 85 */ r"(?-u:\b)module(?-u:\b)", + /* 86 */ r"(?-u:\b)msb(?-u:\b)", + /* 87 */ r"(?-u:\b)output(?-u:\b)", + /* 88 */ r"(?-u:\b)outside(?-u:\b)", + /* 89 */ r"(?-u:\b)package(?-u:\b)", + /* 90 */ r"(?-u:\b)param(?-u:\b)", + /* 91 */ r"(?-u:\b)pub(?-u:\b)", + /* 92 */ r"(?-u:\b)ref(?-u:\b)", + /* 93 */ r"(?-u:\b)repeat(?-u:\b)", + /* 94 */ r"(?-u:\b)reset(?-u:\b)", + /* 95 */ r"(?-u:\b)reset_async_high(?-u:\b)", + /* 96 */ r"(?-u:\b)reset_async_low(?-u:\b)", + /* 97 */ r"(?-u:\b)reset_sync_high(?-u:\b)", + /* 98 */ r"(?-u:\b)reset_sync_low(?-u:\b)", + /* 99 */ r"(?-u:\b)return(?-u:\b)", + /* 100 */ r"(?-u:\b)break(?-u:\b)", + /* 101 */ r"(?-u:\b)signed(?-u:\b)", + /* 102 */ r"(?-u:\b)step(?-u:\b)", + /* 103 */ r"(?-u:\b)string(?-u:\b)", + /* 104 */ r"(?-u:\b)struct(?-u:\b)", + /* 105 */ r"(?-u:\b)tri(?-u:\b)", + /* 106 */ r"(?-u:\b)type(?-u:\b)", + /* 107 */ r"(?-u:\b)u32(?-u:\b)", + /* 108 */ r"(?-u:\b)u64(?-u:\b)", + /* 109 */ r"(?-u:\b)union(?-u:\b)", + /* 110 */ r"(?-u:\b)var(?-u:\b)", + /* 111 */ r"\$[a-zA-Z_][0-9a-zA-Z_$]*", + /* 112 */ r"[a-zA-Z_][0-9a-zA-Z_$]*", + /* 113 */ r"[^{}]*", + /* 114 */ ERROR_TOKEN, ]; -pub const TERMINAL_NAMES: &[&str; 114] = &[ +pub const TERMINAL_NAMES: &[&str; 115] = &[ /* 0 */ "EndOfInput", /* 1 */ "Newline", /* 2 */ "Whitespace", @@ -165,96 +166,97 @@ pub const TERMINAL_NAMES: &[&str; 114] = &[ /* 25 */ "Operator04Term", /* 26 */ "Operator03Term", /* 27 */ "UnaryOperatorTerm", - /* 28 */ "ColonColonTerm", - /* 29 */ "ColonTerm", - /* 30 */ "CommaTerm", - /* 31 */ "DotDotEquTerm", - /* 32 */ "DotDotTerm", - /* 33 */ "DotTerm", - /* 34 */ "EquTerm", - /* 35 */ "HashTerm", - /* 36 */ "LAngleTerm", - /* 37 */ "QuoteLBraceTerm", - /* 38 */ "LBraceTerm", - /* 39 */ "LBracketTerm", - /* 40 */ "LParenTerm", - /* 41 */ "RAngleTerm", - /* 42 */ "RBraceTerm", - /* 43 */ "RBracketTerm", - /* 44 */ "RParenTerm", - /* 45 */ "SemicolonTerm", - /* 46 */ "StarTerm", - /* 47 */ "AlwaysCombTerm", - /* 48 */ "AlwaysFfTerm", - /* 49 */ "AssignTerm", - /* 50 */ "AsTerm", - /* 51 */ "BitTerm", - /* 52 */ "CaseTerm", - /* 53 */ "ClockTerm", - /* 54 */ "ClockPosedgeTerm", - /* 55 */ "ClockNegedgeTerm", - /* 56 */ "DefaultTerm", - /* 57 */ "ElseTerm", - /* 58 */ "EmbedTerm", - /* 59 */ "EnumTerm", - /* 60 */ "ExportTerm", - /* 61 */ "F32Term", - /* 62 */ "F64Term", - /* 63 */ "FinalTerm", - /* 64 */ "ForTerm", - /* 65 */ "FunctionTerm", - /* 66 */ "I32Term", - /* 67 */ "I64Term", - /* 68 */ "IfResetTerm", - /* 69 */ "IfTerm", - /* 70 */ "ImportTerm", - /* 71 */ "IncludeTerm", - /* 72 */ "InitialTerm", - /* 73 */ "InoutTerm", - /* 74 */ "InputTerm", - /* 75 */ "InsideTerm", - /* 76 */ "InstTerm", - /* 77 */ "InterfaceTerm", - /* 78 */ "InTerm", - /* 79 */ "LetTerm", - /* 80 */ "LocalTerm", - /* 81 */ "LogicTerm", - /* 82 */ "LsbTerm", - /* 83 */ "ModportTerm", - /* 84 */ "ModuleTerm", - /* 85 */ "MsbTerm", - /* 86 */ "OutputTerm", - /* 87 */ "OutsideTerm", - /* 88 */ "PackageTerm", - /* 89 */ "ParamTerm", - /* 90 */ "PubTerm", - /* 91 */ "RefTerm", - /* 92 */ "RepeatTerm", - /* 93 */ "ResetTerm", - /* 94 */ "ResetAsyncHighTerm", - /* 95 */ "ResetAsyncLowTerm", - /* 96 */ "ResetSyncHighTerm", - /* 97 */ "ResetSyncLowTerm", - /* 98 */ "ReturnTerm", - /* 99 */ "BreakTerm", - /* 100 */ "SignedTerm", - /* 101 */ "StepTerm", - /* 102 */ "StringTerm", - /* 103 */ "StructTerm", - /* 104 */ "TriTerm", - /* 105 */ "TypeTerm", - /* 106 */ "U32Term", - /* 107 */ "U64Term", - /* 108 */ "UnionTerm", - /* 109 */ "VarTerm", - /* 110 */ "DollarIdentifierTerm", - /* 111 */ "IdentifierTerm", - /* 112 */ "AnyTerm", - /* 113 */ "Error", + /* 28 */ "ColonColonLAngleTerm", + /* 29 */ "ColonColonTerm", + /* 30 */ "ColonTerm", + /* 31 */ "CommaTerm", + /* 32 */ "DotDotEquTerm", + /* 33 */ "DotDotTerm", + /* 34 */ "DotTerm", + /* 35 */ "EquTerm", + /* 36 */ "HashTerm", + /* 37 */ "LAngleTerm", + /* 38 */ "QuoteLBraceTerm", + /* 39 */ "LBraceTerm", + /* 40 */ "LBracketTerm", + /* 41 */ "LParenTerm", + /* 42 */ "RAngleTerm", + /* 43 */ "RBraceTerm", + /* 44 */ "RBracketTerm", + /* 45 */ "RParenTerm", + /* 46 */ "SemicolonTerm", + /* 47 */ "StarTerm", + /* 48 */ "AlwaysCombTerm", + /* 49 */ "AlwaysFfTerm", + /* 50 */ "AssignTerm", + /* 51 */ "AsTerm", + /* 52 */ "BitTerm", + /* 53 */ "CaseTerm", + /* 54 */ "ClockTerm", + /* 55 */ "ClockPosedgeTerm", + /* 56 */ "ClockNegedgeTerm", + /* 57 */ "DefaultTerm", + /* 58 */ "ElseTerm", + /* 59 */ "EmbedTerm", + /* 60 */ "EnumTerm", + /* 61 */ "ExportTerm", + /* 62 */ "F32Term", + /* 63 */ "F64Term", + /* 64 */ "FinalTerm", + /* 65 */ "ForTerm", + /* 66 */ "FunctionTerm", + /* 67 */ "I32Term", + /* 68 */ "I64Term", + /* 69 */ "IfResetTerm", + /* 70 */ "IfTerm", + /* 71 */ "ImportTerm", + /* 72 */ "IncludeTerm", + /* 73 */ "InitialTerm", + /* 74 */ "InoutTerm", + /* 75 */ "InputTerm", + /* 76 */ "InsideTerm", + /* 77 */ "InstTerm", + /* 78 */ "InterfaceTerm", + /* 79 */ "InTerm", + /* 80 */ "LetTerm", + /* 81 */ "LocalTerm", + /* 82 */ "LogicTerm", + /* 83 */ "LsbTerm", + /* 84 */ "ModportTerm", + /* 85 */ "ModuleTerm", + /* 86 */ "MsbTerm", + /* 87 */ "OutputTerm", + /* 88 */ "OutsideTerm", + /* 89 */ "PackageTerm", + /* 90 */ "ParamTerm", + /* 91 */ "PubTerm", + /* 92 */ "RefTerm", + /* 93 */ "RepeatTerm", + /* 94 */ "ResetTerm", + /* 95 */ "ResetAsyncHighTerm", + /* 96 */ "ResetAsyncLowTerm", + /* 97 */ "ResetSyncHighTerm", + /* 98 */ "ResetSyncLowTerm", + /* 99 */ "ReturnTerm", + /* 100 */ "BreakTerm", + /* 101 */ "SignedTerm", + /* 102 */ "StepTerm", + /* 103 */ "StringTerm", + /* 104 */ "StructTerm", + /* 105 */ "TriTerm", + /* 106 */ "TypeTerm", + /* 107 */ "U32Term", + /* 108 */ "U64Term", + /* 109 */ "UnionTerm", + /* 110 */ "VarTerm", + /* 111 */ "DollarIdentifierTerm", + /* 112 */ "IdentifierTerm", + /* 113 */ "AnyTerm", + /* 114 */ "Error", ]; /* SCANNER_0: "INITIAL" */ -const SCANNER_0: (&[&str; 5], &[TerminalIndex; 107]) = ( +const SCANNER_0: (&[&str; 5], &[TerminalIndex; 108]) = ( &[ /* 0 */ UNMATCHABLE_TOKEN, /* 1 */ NEW_LINE_TOKEN, @@ -286,90 +288,91 @@ const SCANNER_0: (&[&str; 5], &[TerminalIndex; 107]) = ( 25, /* Operator04Term */ 26, /* Operator03Term */ 27, /* UnaryOperatorTerm */ - 28, /* ColonColonTerm */ - 29, /* ColonTerm */ - 30, /* CommaTerm */ - 31, /* DotDotEquTerm */ - 32, /* DotDotTerm */ - 33, /* DotTerm */ - 34, /* EquTerm */ - 35, /* HashTerm */ - 36, /* LAngleTerm */ - 37, /* QuoteLBraceTerm */ - 38, /* LBraceTerm */ - 39, /* LBracketTerm */ - 40, /* LParenTerm */ - 41, /* RAngleTerm */ - 42, /* RBraceTerm */ - 43, /* RBracketTerm */ - 44, /* RParenTerm */ - 45, /* SemicolonTerm */ - 46, /* StarTerm */ - 47, /* AlwaysCombTerm */ - 48, /* AlwaysFfTerm */ - 49, /* AssignTerm */ - 50, /* AsTerm */ - 51, /* BitTerm */ - 52, /* CaseTerm */ - 53, /* ClockTerm */ - 54, /* ClockPosedgeTerm */ - 55, /* ClockNegedgeTerm */ - 56, /* DefaultTerm */ - 57, /* ElseTerm */ - 58, /* EmbedTerm */ - 59, /* EnumTerm */ - 60, /* ExportTerm */ - 61, /* F32Term */ - 62, /* F64Term */ - 63, /* FinalTerm */ - 64, /* ForTerm */ - 65, /* FunctionTerm */ - 66, /* I32Term */ - 67, /* I64Term */ - 68, /* IfResetTerm */ - 69, /* IfTerm */ - 70, /* ImportTerm */ - 71, /* IncludeTerm */ - 72, /* InitialTerm */ - 73, /* InoutTerm */ - 74, /* InputTerm */ - 75, /* InsideTerm */ - 76, /* InstTerm */ - 77, /* InterfaceTerm */ - 78, /* InTerm */ - 79, /* LetTerm */ - 80, /* LocalTerm */ - 81, /* LogicTerm */ - 82, /* LsbTerm */ - 83, /* ModportTerm */ - 84, /* ModuleTerm */ - 85, /* MsbTerm */ - 86, /* OutputTerm */ - 87, /* OutsideTerm */ - 88, /* PackageTerm */ - 89, /* ParamTerm */ - 90, /* PubTerm */ - 91, /* RefTerm */ - 92, /* RepeatTerm */ - 93, /* ResetTerm */ - 94, /* ResetAsyncHighTerm */ - 95, /* ResetAsyncLowTerm */ - 96, /* ResetSyncHighTerm */ - 97, /* ResetSyncLowTerm */ - 98, /* ReturnTerm */ - 99, /* BreakTerm */ - 100, /* SignedTerm */ - 101, /* StepTerm */ - 102, /* StringTerm */ - 103, /* StructTerm */ - 104, /* TriTerm */ - 105, /* TypeTerm */ - 106, /* U32Term */ - 107, /* U64Term */ - 108, /* UnionTerm */ - 109, /* VarTerm */ - 110, /* DollarIdentifierTerm */ - 111, /* IdentifierTerm */ + 28, /* ColonColonLAngleTerm */ + 29, /* ColonColonTerm */ + 30, /* ColonTerm */ + 31, /* CommaTerm */ + 32, /* DotDotEquTerm */ + 33, /* DotDotTerm */ + 34, /* DotTerm */ + 35, /* EquTerm */ + 36, /* HashTerm */ + 37, /* LAngleTerm */ + 38, /* QuoteLBraceTerm */ + 39, /* LBraceTerm */ + 40, /* LBracketTerm */ + 41, /* LParenTerm */ + 42, /* RAngleTerm */ + 43, /* RBraceTerm */ + 44, /* RBracketTerm */ + 45, /* RParenTerm */ + 46, /* SemicolonTerm */ + 47, /* StarTerm */ + 48, /* AlwaysCombTerm */ + 49, /* AlwaysFfTerm */ + 50, /* AssignTerm */ + 51, /* AsTerm */ + 52, /* BitTerm */ + 53, /* CaseTerm */ + 54, /* ClockTerm */ + 55, /* ClockPosedgeTerm */ + 56, /* ClockNegedgeTerm */ + 57, /* DefaultTerm */ + 58, /* ElseTerm */ + 59, /* EmbedTerm */ + 60, /* EnumTerm */ + 61, /* ExportTerm */ + 62, /* F32Term */ + 63, /* F64Term */ + 64, /* FinalTerm */ + 65, /* ForTerm */ + 66, /* FunctionTerm */ + 67, /* I32Term */ + 68, /* I64Term */ + 69, /* IfResetTerm */ + 70, /* IfTerm */ + 71, /* ImportTerm */ + 72, /* IncludeTerm */ + 73, /* InitialTerm */ + 74, /* InoutTerm */ + 75, /* InputTerm */ + 76, /* InsideTerm */ + 77, /* InstTerm */ + 78, /* InterfaceTerm */ + 79, /* InTerm */ + 80, /* LetTerm */ + 81, /* LocalTerm */ + 82, /* LogicTerm */ + 83, /* LsbTerm */ + 84, /* ModportTerm */ + 85, /* ModuleTerm */ + 86, /* MsbTerm */ + 87, /* OutputTerm */ + 88, /* OutsideTerm */ + 89, /* PackageTerm */ + 90, /* ParamTerm */ + 91, /* PubTerm */ + 92, /* RefTerm */ + 93, /* RepeatTerm */ + 94, /* ResetTerm */ + 95, /* ResetAsyncHighTerm */ + 96, /* ResetAsyncLowTerm */ + 97, /* ResetSyncHighTerm */ + 98, /* ResetSyncLowTerm */ + 99, /* ReturnTerm */ + 100, /* BreakTerm */ + 101, /* SignedTerm */ + 102, /* StepTerm */ + 103, /* StringTerm */ + 104, /* StructTerm */ + 105, /* TriTerm */ + 106, /* TypeTerm */ + 107, /* U32Term */ + 108, /* U64Term */ + 109, /* UnionTerm */ + 110, /* VarTerm */ + 111, /* DollarIdentifierTerm */ + 112, /* IdentifierTerm */ ], ); @@ -383,15 +386,120 @@ const SCANNER_1: (&[&str; 5], &[TerminalIndex; 3]) = ( /* 4 */ UNMATCHABLE_TOKEN, ], &[ - 38, /* LBraceTerm */ - 42, /* RBraceTerm */ - 112, /* AnyTerm */ + 39, /* LBraceTerm */ + 43, /* RBraceTerm */ + 113, /* AnyTerm */ + ], +); + +/* SCANNER_2: "Generic" */ +const SCANNER_2: (&[&str; 5], &[TerminalIndex; 92]) = ( + &[ + /* 0 */ UNMATCHABLE_TOKEN, + /* 1 */ NEW_LINE_TOKEN, + /* 2 */ WHITESPACE_TOKEN, + /* 3 */ UNMATCHABLE_TOKEN, + /* 4 */ UNMATCHABLE_TOKEN, + ], + &[ + 5, /* CommentsTerm */ + 6, /* StringLiteralTerm */ + 7, /* ExponentTerm */ + 8, /* FixedPointTerm */ + 9, /* BasedTerm */ + 10, /* AllBitTerm */ + 11, /* BaseLessTerm */ + 28, /* ColonColonLAngleTerm */ + 29, /* ColonColonTerm */ + 30, /* ColonTerm */ + 31, /* CommaTerm */ + 32, /* DotDotEquTerm */ + 33, /* DotDotTerm */ + 34, /* DotTerm */ + 35, /* EquTerm */ + 36, /* HashTerm */ + 37, /* LAngleTerm */ + 38, /* QuoteLBraceTerm */ + 39, /* LBraceTerm */ + 40, /* LBracketTerm */ + 41, /* LParenTerm */ + 42, /* RAngleTerm */ + 43, /* RBraceTerm */ + 44, /* RBracketTerm */ + 45, /* RParenTerm */ + 46, /* SemicolonTerm */ + 47, /* StarTerm */ + 48, /* AlwaysCombTerm */ + 49, /* AlwaysFfTerm */ + 50, /* AssignTerm */ + 51, /* AsTerm */ + 52, /* BitTerm */ + 53, /* CaseTerm */ + 54, /* ClockTerm */ + 55, /* ClockPosedgeTerm */ + 56, /* ClockNegedgeTerm */ + 57, /* DefaultTerm */ + 58, /* ElseTerm */ + 59, /* EmbedTerm */ + 60, /* EnumTerm */ + 61, /* ExportTerm */ + 62, /* F32Term */ + 63, /* F64Term */ + 64, /* FinalTerm */ + 65, /* ForTerm */ + 66, /* FunctionTerm */ + 67, /* I32Term */ + 68, /* I64Term */ + 69, /* IfResetTerm */ + 70, /* IfTerm */ + 71, /* ImportTerm */ + 72, /* IncludeTerm */ + 73, /* InitialTerm */ + 74, /* InoutTerm */ + 75, /* InputTerm */ + 76, /* InsideTerm */ + 77, /* InstTerm */ + 78, /* InterfaceTerm */ + 79, /* InTerm */ + 80, /* LetTerm */ + 81, /* LocalTerm */ + 82, /* LogicTerm */ + 83, /* LsbTerm */ + 84, /* ModportTerm */ + 85, /* ModuleTerm */ + 86, /* MsbTerm */ + 87, /* OutputTerm */ + 88, /* OutsideTerm */ + 89, /* PackageTerm */ + 90, /* ParamTerm */ + 91, /* PubTerm */ + 92, /* RefTerm */ + 93, /* RepeatTerm */ + 94, /* ResetTerm */ + 95, /* ResetAsyncHighTerm */ + 96, /* ResetAsyncLowTerm */ + 97, /* ResetSyncHighTerm */ + 98, /* ResetSyncLowTerm */ + 99, /* ReturnTerm */ + 100, /* BreakTerm */ + 101, /* SignedTerm */ + 102, /* StepTerm */ + 103, /* StringTerm */ + 104, /* StructTerm */ + 105, /* TriTerm */ + 106, /* TypeTerm */ + 107, /* U32Term */ + 108, /* U64Term */ + 109, /* UnionTerm */ + 110, /* VarTerm */ + 111, /* DollarIdentifierTerm */ + 112, /* IdentifierTerm */ ], ); const MAX_K: usize = 3; -pub const NON_TERMINALS: &[&str; 616] = &[ +pub const NON_TERMINALS: &[&str; 636] = &[ /* 0 */ "AllBit", /* 1 */ "AllBitTerm", /* 2 */ "AllBitToken", @@ -480,540 +588,560 @@ pub const NON_TERMINALS: &[&str; 616] = &[ /* 85 */ "ClockToken", /* 86 */ "Colon", /* 87 */ "ColonColon", - /* 88 */ "ColonColonTerm", - /* 89 */ "ColonColonToken", - /* 90 */ "ColonTerm", - /* 91 */ "ColonToken", - /* 92 */ "Comma", - /* 93 */ "CommaTerm", - /* 94 */ "CommaToken", - /* 95 */ "Comments", - /* 96 */ "CommentsOpt", - /* 97 */ "CommentsTerm", - /* 98 */ "ConcatenationItem", - /* 99 */ "ConcatenationItemOpt", - /* 100 */ "ConcatenationList", - /* 101 */ "ConcatenationListList", - /* 102 */ "ConcatenationListOpt", - /* 103 */ "Defaul", - /* 104 */ "DefaultTerm", - /* 105 */ "DefaultToken", - /* 106 */ "DescriptionGroup", - /* 107 */ "DescriptionGroupGroup", - /* 108 */ "DescriptionGroupGroupList", - /* 109 */ "DescriptionGroupList", - /* 110 */ "DescriptionItem", - /* 111 */ "Direction", - /* 112 */ "DollarIdentifier", - /* 113 */ "DollarIdentifierTerm", - /* 114 */ "DollarIdentifierToken", - /* 115 */ "Dot", - /* 116 */ "DotDot", - /* 117 */ "DotDotEqu", - /* 118 */ "DotDotEquTerm", - /* 119 */ "DotDotEquToken", - /* 120 */ "DotDotTerm", - /* 121 */ "DotDotToken", - /* 122 */ "DotTerm", - /* 123 */ "DotToken", - /* 124 */ "Else", - /* 125 */ "ElseTerm", - /* 126 */ "ElseToken", - /* 127 */ "Embed", - /* 128 */ "EmbedContent", - /* 129 */ "EmbedContentToken", - /* 130 */ "EmbedContentTokenList", - /* 131 */ "EmbedDeclaration", - /* 132 */ "EmbedItem", - /* 133 */ "EmbedItemList", - /* 134 */ "EmbedTerm", - /* 135 */ "EmbedToken", - /* 136 */ "Enum", - /* 137 */ "EnumDeclaration", - /* 138 */ "EnumGroup", - /* 139 */ "EnumGroupGroup", - /* 140 */ "EnumGroupList", - /* 141 */ "EnumItem", - /* 142 */ "EnumItemOpt", - /* 143 */ "EnumList", - /* 144 */ "EnumListList", - /* 145 */ "EnumListOpt", - /* 146 */ "EnumTerm", - /* 147 */ "EnumToken", - /* 148 */ "Equ", - /* 149 */ "EquTerm", - /* 150 */ "EquToken", - /* 151 */ "Exponent", - /* 152 */ "ExponentTerm", - /* 153 */ "ExponentToken", - /* 154 */ "Export", - /* 155 */ "ExportDeclaration", - /* 156 */ "ExportDeclarationGroup", - /* 157 */ "ExportDeclarationOpt", - /* 158 */ "ExportTerm", - /* 159 */ "ExportToken", - /* 160 */ "Expression", - /* 161 */ "Expression01", - /* 162 */ "Expression01List", - /* 163 */ "Expression02", - /* 164 */ "Expression02List", - /* 165 */ "Expression03", - /* 166 */ "Expression03List", - /* 167 */ "Expression04", - /* 168 */ "Expression04List", - /* 169 */ "Expression05", - /* 170 */ "Expression05List", - /* 171 */ "Expression06", - /* 172 */ "Expression06List", - /* 173 */ "Expression07", - /* 174 */ "Expression07List", - /* 175 */ "Expression08", - /* 176 */ "Expression08List", - /* 177 */ "Expression09", - /* 178 */ "Expression09List", - /* 179 */ "Expression09ListGroup", - /* 180 */ "Expression10", - /* 181 */ "Expression10List", - /* 182 */ "Expression11", - /* 183 */ "Expression11List", - /* 184 */ "Expression12", - /* 185 */ "Expression12List", - /* 186 */ "Expression12ListGroup", - /* 187 */ "ExpressionIdentifier", - /* 188 */ "ExpressionIdentifierList", - /* 189 */ "ExpressionIdentifierList0", - /* 190 */ "ExpressionIdentifierList0List", - /* 191 */ "ExpressionList", - /* 192 */ "F32", - /* 193 */ "F32Term", - /* 194 */ "F32Token", - /* 195 */ "F64", - /* 196 */ "F64Term", - /* 197 */ "F64Token", - /* 198 */ "Factor", - /* 199 */ "FactorGroup", - /* 200 */ "FactorOpt", - /* 201 */ "Final", - /* 202 */ "FinalDeclaration", - /* 203 */ "FinalDeclarationList", - /* 204 */ "FinalTerm", - /* 205 */ "FinalToken", - /* 206 */ "FixedPoint", - /* 207 */ "FixedPointTerm", - /* 208 */ "FixedPointToken", - /* 209 */ "FixedType", - /* 210 */ "For", - /* 211 */ "ForStatement", - /* 212 */ "ForStatementList", - /* 213 */ "ForStatementOpt", - /* 214 */ "ForTerm", - /* 215 */ "ForToken", - /* 216 */ "Function", - /* 217 */ "FunctionCall", - /* 218 */ "FunctionCallOpt", - /* 219 */ "FunctionDeclaration", - /* 220 */ "FunctionDeclarationList", - /* 221 */ "FunctionDeclarationOpt", - /* 222 */ "FunctionDeclarationOpt0", - /* 223 */ "FunctionItem", - /* 224 */ "FunctionTerm", - /* 225 */ "FunctionToken", - /* 226 */ "Hash", - /* 227 */ "HashTerm", - /* 228 */ "HashToken", - /* 229 */ "HierarchicalIdentifier", - /* 230 */ "HierarchicalIdentifierList", - /* 231 */ "HierarchicalIdentifierList0", - /* 232 */ "HierarchicalIdentifierList0List", - /* 233 */ "I32", - /* 234 */ "I32Term", - /* 235 */ "I32Token", - /* 236 */ "I64", - /* 237 */ "I64Term", - /* 238 */ "I64Token", - /* 239 */ "Identifier", - /* 240 */ "IdentifierStatement", - /* 241 */ "IdentifierStatementGroup", - /* 242 */ "IdentifierTerm", - /* 243 */ "IdentifierToken", - /* 244 */ "If", - /* 245 */ "IfExpression", - /* 246 */ "IfExpressionList", - /* 247 */ "IfReset", - /* 248 */ "IfResetStatement", - /* 249 */ "IfResetStatementList", - /* 250 */ "IfResetStatementList0", - /* 251 */ "IfResetStatementList0List", - /* 252 */ "IfResetStatementOpt", - /* 253 */ "IfResetStatementOptList", - /* 254 */ "IfResetTerm", - /* 255 */ "IfResetToken", - /* 256 */ "IfStatement", - /* 257 */ "IfStatementList", - /* 258 */ "IfStatementList0", - /* 259 */ "IfStatementList0List", - /* 260 */ "IfStatementOpt", - /* 261 */ "IfStatementOptList", - /* 262 */ "IfTerm", - /* 263 */ "IfToken", - /* 264 */ "Import", - /* 265 */ "ImportDeclaration", - /* 266 */ "ImportDeclarationOpt", - /* 267 */ "ImportTerm", - /* 268 */ "ImportToken", - /* 269 */ "In", - /* 270 */ "InTerm", - /* 271 */ "InToken", - /* 272 */ "Include", - /* 273 */ "IncludeDeclaration", - /* 274 */ "IncludeTerm", - /* 275 */ "IncludeToken", - /* 276 */ "Initial", - /* 277 */ "InitialDeclaration", - /* 278 */ "InitialDeclarationList", - /* 279 */ "InitialTerm", - /* 280 */ "InitialToken", - /* 281 */ "Inout", - /* 282 */ "InoutTerm", - /* 283 */ "InoutToken", - /* 284 */ "Input", - /* 285 */ "InputTerm", - /* 286 */ "InputToken", - /* 287 */ "Inside", - /* 288 */ "InsideExpression", - /* 289 */ "InsideTerm", - /* 290 */ "InsideToken", - /* 291 */ "Inst", - /* 292 */ "InstDeclaration", - /* 293 */ "InstDeclarationOpt", - /* 294 */ "InstDeclarationOpt0", - /* 295 */ "InstDeclarationOpt1", - /* 296 */ "InstDeclarationOpt2", - /* 297 */ "InstParameter", - /* 298 */ "InstParameterGroup", - /* 299 */ "InstParameterGroupGroup", - /* 300 */ "InstParameterGroupList", - /* 301 */ "InstParameterItem", - /* 302 */ "InstParameterItemOpt", - /* 303 */ "InstParameterList", - /* 304 */ "InstParameterListList", - /* 305 */ "InstParameterListOpt", - /* 306 */ "InstParameterOpt", - /* 307 */ "InstPortGroup", - /* 308 */ "InstPortGroupGroup", - /* 309 */ "InstPortGroupList", - /* 310 */ "InstPortItem", - /* 311 */ "InstPortItemOpt", - /* 312 */ "InstPortList", - /* 313 */ "InstPortListList", - /* 314 */ "InstPortListOpt", - /* 315 */ "InstTerm", - /* 316 */ "InstToken", - /* 317 */ "IntegralNumber", - /* 318 */ "Interface", - /* 319 */ "InterfaceDeclaration", - /* 320 */ "InterfaceDeclarationList", - /* 321 */ "InterfaceDeclarationOpt", - /* 322 */ "InterfaceDeclarationOpt0", - /* 323 */ "InterfaceForDeclaration", - /* 324 */ "InterfaceForDeclarationOpt", - /* 325 */ "InterfaceGroup", - /* 326 */ "InterfaceGroupGroup", - /* 327 */ "InterfaceGroupGroupList", - /* 328 */ "InterfaceGroupList", - /* 329 */ "InterfaceIfDeclaration", - /* 330 */ "InterfaceIfDeclarationList", - /* 331 */ "InterfaceIfDeclarationOpt", - /* 332 */ "InterfaceItem", - /* 333 */ "InterfaceNamedBlock", - /* 334 */ "InterfaceNamedBlockList", - /* 335 */ "InterfaceOptionalNamedBlock", - /* 336 */ "InterfaceOptionalNamedBlockList", - /* 337 */ "InterfaceOptionalNamedBlockOpt", - /* 338 */ "InterfaceTerm", - /* 339 */ "InterfaceToken", - /* 340 */ "LAngle", - /* 341 */ "LAngleTerm", - /* 342 */ "LAngleToken", - /* 343 */ "LBrace", - /* 344 */ "LBraceTerm", - /* 345 */ "LBraceToken", - /* 346 */ "LBracket", - /* 347 */ "LBracketTerm", - /* 348 */ "LBracketToken", - /* 349 */ "LParen", - /* 350 */ "LParenTerm", - /* 351 */ "LParenToken", - /* 352 */ "Let", - /* 353 */ "LetDeclaration", - /* 354 */ "LetStatement", - /* 355 */ "LetTerm", - /* 356 */ "LetToken", - /* 357 */ "Local", - /* 358 */ "LocalDeclaration", - /* 359 */ "LocalDeclarationGroup", - /* 360 */ "LocalTerm", - /* 361 */ "LocalToken", - /* 362 */ "Logic", - /* 363 */ "LogicTerm", - /* 364 */ "LogicToken", - /* 365 */ "Lsb", - /* 366 */ "LsbTerm", - /* 367 */ "LsbToken", - /* 368 */ "MinusColon", - /* 369 */ "MinusColonTerm", - /* 370 */ "MinusColonToken", - /* 371 */ "MinusGT", - /* 372 */ "MinusGTTerm", - /* 373 */ "MinusGTToken", - /* 374 */ "Modport", - /* 375 */ "ModportDeclaration", - /* 376 */ "ModportGroup", - /* 377 */ "ModportGroupGroup", - /* 378 */ "ModportGroupList", - /* 379 */ "ModportItem", - /* 380 */ "ModportList", - /* 381 */ "ModportListList", - /* 382 */ "ModportListOpt", - /* 383 */ "ModportTerm", - /* 384 */ "ModportToken", - /* 385 */ "Module", - /* 386 */ "ModuleDeclaration", - /* 387 */ "ModuleDeclarationList", - /* 388 */ "ModuleDeclarationOpt", - /* 389 */ "ModuleDeclarationOpt0", - /* 390 */ "ModuleDeclarationOpt1", - /* 391 */ "ModuleForDeclaration", - /* 392 */ "ModuleForDeclarationOpt", - /* 393 */ "ModuleGroup", - /* 394 */ "ModuleGroupGroup", - /* 395 */ "ModuleGroupGroupList", - /* 396 */ "ModuleGroupList", - /* 397 */ "ModuleIfDeclaration", - /* 398 */ "ModuleIfDeclarationList", - /* 399 */ "ModuleIfDeclarationOpt", - /* 400 */ "ModuleItem", - /* 401 */ "ModuleNamedBlock", - /* 402 */ "ModuleNamedBlockList", - /* 403 */ "ModuleOptionalNamedBlock", - /* 404 */ "ModuleOptionalNamedBlockList", - /* 405 */ "ModuleOptionalNamedBlockOpt", - /* 406 */ "ModuleTerm", - /* 407 */ "ModuleToken", - /* 408 */ "Msb", - /* 409 */ "MsbTerm", - /* 410 */ "MsbToken", - /* 411 */ "Number", - /* 412 */ "Operator01", - /* 413 */ "Operator01Term", - /* 414 */ "Operator01Token", - /* 415 */ "Operator02", - /* 416 */ "Operator02Term", - /* 417 */ "Operator02Token", - /* 418 */ "Operator03", - /* 419 */ "Operator03Term", - /* 420 */ "Operator03Token", - /* 421 */ "Operator04", - /* 422 */ "Operator04Term", - /* 423 */ "Operator04Token", - /* 424 */ "Operator05", - /* 425 */ "Operator05Term", - /* 426 */ "Operator05Token", - /* 427 */ "Operator06", - /* 428 */ "Operator06Term", - /* 429 */ "Operator06Token", - /* 430 */ "Operator07", - /* 431 */ "Operator07Term", - /* 432 */ "Operator07Token", - /* 433 */ "Operator08", - /* 434 */ "Operator08Term", - /* 435 */ "Operator08Token", - /* 436 */ "Operator09", - /* 437 */ "Operator09Term", - /* 438 */ "Operator09Token", - /* 439 */ "Operator10", - /* 440 */ "Operator10Term", - /* 441 */ "Operator10Token", - /* 442 */ "Operator11", - /* 443 */ "Operator11Term", - /* 444 */ "Operator11Token", - /* 445 */ "Output", - /* 446 */ "OutputTerm", - /* 447 */ "OutputToken", - /* 448 */ "Outside", - /* 449 */ "OutsideExpression", - /* 450 */ "OutsideTerm", - /* 451 */ "OutsideToken", - /* 452 */ "Package", - /* 453 */ "PackageDeclaration", - /* 454 */ "PackageDeclarationList", - /* 455 */ "PackageDeclarationOpt", - /* 456 */ "PackageGroup", - /* 457 */ "PackageGroupGroup", - /* 458 */ "PackageGroupGroupList", - /* 459 */ "PackageGroupList", - /* 460 */ "PackageItem", - /* 461 */ "PackageTerm", - /* 462 */ "PackageToken", - /* 463 */ "Param", - /* 464 */ "ParamTerm", - /* 465 */ "ParamToken", - /* 466 */ "PlusColon", - /* 467 */ "PlusColonTerm", - /* 468 */ "PlusColonToken", - /* 469 */ "PortDeclaration", - /* 470 */ "PortDeclarationGroup", - /* 471 */ "PortDeclarationGroupGroup", - /* 472 */ "PortDeclarationGroupList", - /* 473 */ "PortDeclarationItem", - /* 474 */ "PortDeclarationItemGroup", - /* 475 */ "PortDeclarationItemOpt", - /* 476 */ "PortDeclarationList", - /* 477 */ "PortDeclarationListList", - /* 478 */ "PortDeclarationListOpt", - /* 479 */ "PortDeclarationOpt", - /* 480 */ "Pub", - /* 481 */ "PubTerm", - /* 482 */ "PubToken", - /* 483 */ "QuoteLBrace", - /* 484 */ "QuoteLBraceTerm", - /* 485 */ "QuoteLBraceToken", - /* 486 */ "RAngle", - /* 487 */ "RAngleTerm", - /* 488 */ "RAngleToken", - /* 489 */ "RBrace", - /* 490 */ "RBraceTerm", - /* 491 */ "RBraceToken", - /* 492 */ "RBracket", - /* 493 */ "RBracketTerm", - /* 494 */ "RBracketToken", - /* 495 */ "RParen", - /* 496 */ "RParenTerm", - /* 497 */ "RParenToken", - /* 498 */ "Range", - /* 499 */ "RangeItem", - /* 500 */ "RangeList", - /* 501 */ "RangeListList", - /* 502 */ "RangeListOpt", - /* 503 */ "RangeOperator", - /* 504 */ "RangeOpt", - /* 505 */ "RealNumber", - /* 506 */ "Ref", - /* 507 */ "RefTerm", - /* 508 */ "RefToken", - /* 509 */ "Repeat", - /* 510 */ "RepeatTerm", - /* 511 */ "RepeatToken", - /* 512 */ "Reset", - /* 513 */ "ResetAsyncHigh", - /* 514 */ "ResetAsyncHighTerm", - /* 515 */ "ResetAsyncHighToken", - /* 516 */ "ResetAsyncLow", - /* 517 */ "ResetAsyncLowTerm", - /* 518 */ "ResetAsyncLowToken", - /* 519 */ "ResetSyncHigh", - /* 520 */ "ResetSyncHighTerm", - /* 521 */ "ResetSyncHighToken", - /* 522 */ "ResetSyncLow", - /* 523 */ "ResetSyncLowTerm", - /* 524 */ "ResetSyncLowToken", - /* 525 */ "ResetTerm", - /* 526 */ "ResetToken", - /* 527 */ "Return", - /* 528 */ "ReturnStatement", - /* 529 */ "ReturnTerm", - /* 530 */ "ReturnToken", - /* 531 */ "ScalarType", - /* 532 */ "ScalarTypeGroup", - /* 533 */ "ScalarTypeList", - /* 534 */ "ScopedIdentifier", - /* 535 */ "ScopedIdentifierGroup", - /* 536 */ "ScopedIdentifierList", - /* 537 */ "Select", - /* 538 */ "SelectOperator", - /* 539 */ "SelectOpt", - /* 540 */ "Semicolon", - /* 541 */ "SemicolonTerm", - /* 542 */ "SemicolonToken", - /* 543 */ "Signed", - /* 544 */ "SignedTerm", - /* 545 */ "SignedToken", - /* 546 */ "Star", - /* 547 */ "StarTerm", - /* 548 */ "StarToken", - /* 549 */ "Start", - /* 550 */ "StartToken", - /* 551 */ "Statement", - /* 552 */ "Step", - /* 553 */ "StepTerm", - /* 554 */ "StepToken", - /* 555 */ "Strin", - /* 556 */ "StringLiteral", - /* 557 */ "StringLiteralTerm", - /* 558 */ "StringLiteralToken", - /* 559 */ "StringTerm", - /* 560 */ "StringToken", - /* 561 */ "Struct", - /* 562 */ "StructTerm", - /* 563 */ "StructToken", - /* 564 */ "StructUnion", - /* 565 */ "StructUnionDeclaration", - /* 566 */ "StructUnionGroup", - /* 567 */ "StructUnionGroupGroup", - /* 568 */ "StructUnionGroupList", - /* 569 */ "StructUnionItem", - /* 570 */ "StructUnionList", - /* 571 */ "StructUnionListList", - /* 572 */ "StructUnionListOpt", - /* 573 */ "Tri", - /* 574 */ "TriTerm", - /* 575 */ "TriToken", - /* 576 */ "Type", - /* 577 */ "TypeDefDeclaration", - /* 578 */ "TypeExpression", - /* 579 */ "TypeModifier", - /* 580 */ "TypeTerm", - /* 581 */ "TypeToken", - /* 582 */ "U32", - /* 583 */ "U32Term", - /* 584 */ "U32Token", - /* 585 */ "U64", - /* 586 */ "U64Term", - /* 587 */ "U64Token", - /* 588 */ "UnaryOperator", - /* 589 */ "UnaryOperatorTerm", - /* 590 */ "UnaryOperatorToken", - /* 591 */ "Union", - /* 592 */ "UnionTerm", - /* 593 */ "UnionToken", - /* 594 */ "Var", - /* 595 */ "VarDeclaration", - /* 596 */ "VarTerm", - /* 597 */ "VarToken", - /* 598 */ "VariableType", - /* 599 */ "VariableTypeGroup", - /* 600 */ "VariableTypeOpt", - /* 601 */ "Veryl", - /* 602 */ "VerylList", - /* 603 */ "Width", - /* 604 */ "WidthList", - /* 605 */ "WithParameter", - /* 606 */ "WithParameterGroup", - /* 607 */ "WithParameterGroupGroup", - /* 608 */ "WithParameterGroupList", - /* 609 */ "WithParameterItem", - /* 610 */ "WithParameterItemGroup", - /* 611 */ "WithParameterItemGroup0", - /* 612 */ "WithParameterList", - /* 613 */ "WithParameterListList", - /* 614 */ "WithParameterListOpt", - /* 615 */ "WithParameterOpt", + /* 88 */ "ColonColonLAngle", + /* 89 */ "ColonColonLAngleTerm", + /* 90 */ "ColonColonLAngleToken", + /* 91 */ "ColonColonTerm", + /* 92 */ "ColonColonToken", + /* 93 */ "ColonTerm", + /* 94 */ "ColonToken", + /* 95 */ "Comma", + /* 96 */ "CommaTerm", + /* 97 */ "CommaToken", + /* 98 */ "Comments", + /* 99 */ "CommentsOpt", + /* 100 */ "CommentsTerm", + /* 101 */ "ConcatenationItem", + /* 102 */ "ConcatenationItemOpt", + /* 103 */ "ConcatenationList", + /* 104 */ "ConcatenationListList", + /* 105 */ "ConcatenationListOpt", + /* 106 */ "Defaul", + /* 107 */ "DefaultTerm", + /* 108 */ "DefaultToken", + /* 109 */ "DescriptionGroup", + /* 110 */ "DescriptionGroupGroup", + /* 111 */ "DescriptionGroupGroupList", + /* 112 */ "DescriptionGroupList", + /* 113 */ "DescriptionItem", + /* 114 */ "Direction", + /* 115 */ "DollarIdentifier", + /* 116 */ "DollarIdentifierTerm", + /* 117 */ "DollarIdentifierToken", + /* 118 */ "Dot", + /* 119 */ "DotDot", + /* 120 */ "DotDotEqu", + /* 121 */ "DotDotEquTerm", + /* 122 */ "DotDotEquToken", + /* 123 */ "DotDotTerm", + /* 124 */ "DotDotToken", + /* 125 */ "DotTerm", + /* 126 */ "DotToken", + /* 127 */ "Else", + /* 128 */ "ElseTerm", + /* 129 */ "ElseToken", + /* 130 */ "Embed", + /* 131 */ "EmbedContent", + /* 132 */ "EmbedContentToken", + /* 133 */ "EmbedContentTokenList", + /* 134 */ "EmbedDeclaration", + /* 135 */ "EmbedItem", + /* 136 */ "EmbedItemList", + /* 137 */ "EmbedTerm", + /* 138 */ "EmbedToken", + /* 139 */ "Enum", + /* 140 */ "EnumDeclaration", + /* 141 */ "EnumGroup", + /* 142 */ "EnumGroupGroup", + /* 143 */ "EnumGroupList", + /* 144 */ "EnumItem", + /* 145 */ "EnumItemOpt", + /* 146 */ "EnumList", + /* 147 */ "EnumListList", + /* 148 */ "EnumListOpt", + /* 149 */ "EnumTerm", + /* 150 */ "EnumToken", + /* 151 */ "Equ", + /* 152 */ "EquTerm", + /* 153 */ "EquToken", + /* 154 */ "Exponent", + /* 155 */ "ExponentTerm", + /* 156 */ "ExponentToken", + /* 157 */ "Export", + /* 158 */ "ExportDeclaration", + /* 159 */ "ExportDeclarationGroup", + /* 160 */ "ExportDeclarationOpt", + /* 161 */ "ExportTerm", + /* 162 */ "ExportToken", + /* 163 */ "Expression", + /* 164 */ "Expression01", + /* 165 */ "Expression01List", + /* 166 */ "Expression02", + /* 167 */ "Expression02List", + /* 168 */ "Expression03", + /* 169 */ "Expression03List", + /* 170 */ "Expression04", + /* 171 */ "Expression04List", + /* 172 */ "Expression05", + /* 173 */ "Expression05List", + /* 174 */ "Expression06", + /* 175 */ "Expression06List", + /* 176 */ "Expression07", + /* 177 */ "Expression07List", + /* 178 */ "Expression08", + /* 179 */ "Expression08List", + /* 180 */ "Expression09", + /* 181 */ "Expression09List", + /* 182 */ "Expression09ListGroup", + /* 183 */ "Expression10", + /* 184 */ "Expression10List", + /* 185 */ "Expression11", + /* 186 */ "Expression11List", + /* 187 */ "Expression12", + /* 188 */ "Expression12List", + /* 189 */ "Expression12ListGroup", + /* 190 */ "ExpressionIdentifier", + /* 191 */ "ExpressionIdentifierList", + /* 192 */ "ExpressionIdentifierList0", + /* 193 */ "ExpressionIdentifierList0List", + /* 194 */ "ExpressionList", + /* 195 */ "F32", + /* 196 */ "F32Term", + /* 197 */ "F32Token", + /* 198 */ "F64", + /* 199 */ "F64Term", + /* 200 */ "F64Token", + /* 201 */ "Factor", + /* 202 */ "FactorGroup", + /* 203 */ "FactorOpt", + /* 204 */ "Final", + /* 205 */ "FinalDeclaration", + /* 206 */ "FinalDeclarationList", + /* 207 */ "FinalTerm", + /* 208 */ "FinalToken", + /* 209 */ "FixedPoint", + /* 210 */ "FixedPointTerm", + /* 211 */ "FixedPointToken", + /* 212 */ "FixedType", + /* 213 */ "For", + /* 214 */ "ForStatement", + /* 215 */ "ForStatementList", + /* 216 */ "ForStatementOpt", + /* 217 */ "ForTerm", + /* 218 */ "ForToken", + /* 219 */ "Function", + /* 220 */ "FunctionCall", + /* 221 */ "FunctionCallOpt", + /* 222 */ "FunctionDeclaration", + /* 223 */ "FunctionDeclarationList", + /* 224 */ "FunctionDeclarationOpt", + /* 225 */ "FunctionDeclarationOpt0", + /* 226 */ "FunctionDeclarationOpt1", + /* 227 */ "FunctionItem", + /* 228 */ "FunctionTerm", + /* 229 */ "FunctionToken", + /* 230 */ "Hash", + /* 231 */ "HashTerm", + /* 232 */ "HashToken", + /* 233 */ "HierarchicalIdentifier", + /* 234 */ "HierarchicalIdentifierList", + /* 235 */ "HierarchicalIdentifierList0", + /* 236 */ "HierarchicalIdentifierList0List", + /* 237 */ "I32", + /* 238 */ "I32Term", + /* 239 */ "I32Token", + /* 240 */ "I64", + /* 241 */ "I64Term", + /* 242 */ "I64Token", + /* 243 */ "Identifier", + /* 244 */ "IdentifierStatement", + /* 245 */ "IdentifierStatementGroup", + /* 246 */ "IdentifierTerm", + /* 247 */ "IdentifierToken", + /* 248 */ "If", + /* 249 */ "IfExpression", + /* 250 */ "IfExpressionList", + /* 251 */ "IfReset", + /* 252 */ "IfResetStatement", + /* 253 */ "IfResetStatementList", + /* 254 */ "IfResetStatementList0", + /* 255 */ "IfResetStatementList0List", + /* 256 */ "IfResetStatementOpt", + /* 257 */ "IfResetStatementOptList", + /* 258 */ "IfResetTerm", + /* 259 */ "IfResetToken", + /* 260 */ "IfStatement", + /* 261 */ "IfStatementList", + /* 262 */ "IfStatementList0", + /* 263 */ "IfStatementList0List", + /* 264 */ "IfStatementOpt", + /* 265 */ "IfStatementOptList", + /* 266 */ "IfTerm", + /* 267 */ "IfToken", + /* 268 */ "Import", + /* 269 */ "ImportDeclaration", + /* 270 */ "ImportDeclarationOpt", + /* 271 */ "ImportTerm", + /* 272 */ "ImportToken", + /* 273 */ "In", + /* 274 */ "InTerm", + /* 275 */ "InToken", + /* 276 */ "Include", + /* 277 */ "IncludeDeclaration", + /* 278 */ "IncludeTerm", + /* 279 */ "IncludeToken", + /* 280 */ "Initial", + /* 281 */ "InitialDeclaration", + /* 282 */ "InitialDeclarationList", + /* 283 */ "InitialTerm", + /* 284 */ "InitialToken", + /* 285 */ "Inout", + /* 286 */ "InoutTerm", + /* 287 */ "InoutToken", + /* 288 */ "Input", + /* 289 */ "InputTerm", + /* 290 */ "InputToken", + /* 291 */ "Inside", + /* 292 */ "InsideExpression", + /* 293 */ "InsideTerm", + /* 294 */ "InsideToken", + /* 295 */ "Inst", + /* 296 */ "InstDeclaration", + /* 297 */ "InstDeclarationOpt", + /* 298 */ "InstDeclarationOpt0", + /* 299 */ "InstDeclarationOpt1", + /* 300 */ "InstDeclarationOpt2", + /* 301 */ "InstParameter", + /* 302 */ "InstParameterGroup", + /* 303 */ "InstParameterGroupGroup", + /* 304 */ "InstParameterGroupList", + /* 305 */ "InstParameterItem", + /* 306 */ "InstParameterItemOpt", + /* 307 */ "InstParameterList", + /* 308 */ "InstParameterListList", + /* 309 */ "InstParameterListOpt", + /* 310 */ "InstParameterOpt", + /* 311 */ "InstPortGroup", + /* 312 */ "InstPortGroupGroup", + /* 313 */ "InstPortGroupList", + /* 314 */ "InstPortItem", + /* 315 */ "InstPortItemOpt", + /* 316 */ "InstPortList", + /* 317 */ "InstPortListList", + /* 318 */ "InstPortListOpt", + /* 319 */ "InstTerm", + /* 320 */ "InstToken", + /* 321 */ "IntegralNumber", + /* 322 */ "Interface", + /* 323 */ "InterfaceDeclaration", + /* 324 */ "InterfaceDeclarationList", + /* 325 */ "InterfaceDeclarationOpt", + /* 326 */ "InterfaceDeclarationOpt0", + /* 327 */ "InterfaceDeclarationOpt1", + /* 328 */ "InterfaceForDeclaration", + /* 329 */ "InterfaceForDeclarationOpt", + /* 330 */ "InterfaceGroup", + /* 331 */ "InterfaceGroupGroup", + /* 332 */ "InterfaceGroupGroupList", + /* 333 */ "InterfaceGroupList", + /* 334 */ "InterfaceIfDeclaration", + /* 335 */ "InterfaceIfDeclarationList", + /* 336 */ "InterfaceIfDeclarationOpt", + /* 337 */ "InterfaceItem", + /* 338 */ "InterfaceNamedBlock", + /* 339 */ "InterfaceNamedBlockList", + /* 340 */ "InterfaceOptionalNamedBlock", + /* 341 */ "InterfaceOptionalNamedBlockList", + /* 342 */ "InterfaceOptionalNamedBlockOpt", + /* 343 */ "InterfaceTerm", + /* 344 */ "InterfaceToken", + /* 345 */ "LAngle", + /* 346 */ "LAngleTerm", + /* 347 */ "LAngleToken", + /* 348 */ "LBrace", + /* 349 */ "LBraceTerm", + /* 350 */ "LBraceToken", + /* 351 */ "LBracket", + /* 352 */ "LBracketTerm", + /* 353 */ "LBracketToken", + /* 354 */ "LParen", + /* 355 */ "LParenTerm", + /* 356 */ "LParenToken", + /* 357 */ "Let", + /* 358 */ "LetDeclaration", + /* 359 */ "LetStatement", + /* 360 */ "LetTerm", + /* 361 */ "LetToken", + /* 362 */ "Local", + /* 363 */ "LocalDeclaration", + /* 364 */ "LocalDeclarationGroup", + /* 365 */ "LocalTerm", + /* 366 */ "LocalToken", + /* 367 */ "Logic", + /* 368 */ "LogicTerm", + /* 369 */ "LogicToken", + /* 370 */ "Lsb", + /* 371 */ "LsbTerm", + /* 372 */ "LsbToken", + /* 373 */ "MinusColon", + /* 374 */ "MinusColonTerm", + /* 375 */ "MinusColonToken", + /* 376 */ "MinusGT", + /* 377 */ "MinusGTTerm", + /* 378 */ "MinusGTToken", + /* 379 */ "Modport", + /* 380 */ "ModportDeclaration", + /* 381 */ "ModportGroup", + /* 382 */ "ModportGroupGroup", + /* 383 */ "ModportGroupList", + /* 384 */ "ModportItem", + /* 385 */ "ModportList", + /* 386 */ "ModportListList", + /* 387 */ "ModportListOpt", + /* 388 */ "ModportTerm", + /* 389 */ "ModportToken", + /* 390 */ "Module", + /* 391 */ "ModuleDeclaration", + /* 392 */ "ModuleDeclarationList", + /* 393 */ "ModuleDeclarationOpt", + /* 394 */ "ModuleDeclarationOpt0", + /* 395 */ "ModuleDeclarationOpt1", + /* 396 */ "ModuleDeclarationOpt2", + /* 397 */ "ModuleForDeclaration", + /* 398 */ "ModuleForDeclarationOpt", + /* 399 */ "ModuleGroup", + /* 400 */ "ModuleGroupGroup", + /* 401 */ "ModuleGroupGroupList", + /* 402 */ "ModuleGroupList", + /* 403 */ "ModuleIfDeclaration", + /* 404 */ "ModuleIfDeclarationList", + /* 405 */ "ModuleIfDeclarationOpt", + /* 406 */ "ModuleItem", + /* 407 */ "ModuleNamedBlock", + /* 408 */ "ModuleNamedBlockList", + /* 409 */ "ModuleOptionalNamedBlock", + /* 410 */ "ModuleOptionalNamedBlockList", + /* 411 */ "ModuleOptionalNamedBlockOpt", + /* 412 */ "ModuleTerm", + /* 413 */ "ModuleToken", + /* 414 */ "Msb", + /* 415 */ "MsbTerm", + /* 416 */ "MsbToken", + /* 417 */ "Number", + /* 418 */ "Operator01", + /* 419 */ "Operator01Term", + /* 420 */ "Operator01Token", + /* 421 */ "Operator02", + /* 422 */ "Operator02Term", + /* 423 */ "Operator02Token", + /* 424 */ "Operator03", + /* 425 */ "Operator03Term", + /* 426 */ "Operator03Token", + /* 427 */ "Operator04", + /* 428 */ "Operator04Term", + /* 429 */ "Operator04Token", + /* 430 */ "Operator05", + /* 431 */ "Operator05Term", + /* 432 */ "Operator05Token", + /* 433 */ "Operator06", + /* 434 */ "Operator06Term", + /* 435 */ "Operator06Token", + /* 436 */ "Operator07", + /* 437 */ "Operator07Term", + /* 438 */ "Operator07Token", + /* 439 */ "Operator08", + /* 440 */ "Operator08Term", + /* 441 */ "Operator08Token", + /* 442 */ "Operator09", + /* 443 */ "Operator09Term", + /* 444 */ "Operator09Token", + /* 445 */ "Operator10", + /* 446 */ "Operator10Term", + /* 447 */ "Operator10Token", + /* 448 */ "Operator11", + /* 449 */ "Operator11Term", + /* 450 */ "Operator11Token", + /* 451 */ "Output", + /* 452 */ "OutputTerm", + /* 453 */ "OutputToken", + /* 454 */ "Outside", + /* 455 */ "OutsideExpression", + /* 456 */ "OutsideTerm", + /* 457 */ "OutsideToken", + /* 458 */ "Package", + /* 459 */ "PackageDeclaration", + /* 460 */ "PackageDeclarationList", + /* 461 */ "PackageDeclarationOpt", + /* 462 */ "PackageDeclarationOpt0", + /* 463 */ "PackageGroup", + /* 464 */ "PackageGroupGroup", + /* 465 */ "PackageGroupGroupList", + /* 466 */ "PackageGroupList", + /* 467 */ "PackageItem", + /* 468 */ "PackageTerm", + /* 469 */ "PackageToken", + /* 470 */ "Param", + /* 471 */ "ParamTerm", + /* 472 */ "ParamToken", + /* 473 */ "PlusColon", + /* 474 */ "PlusColonTerm", + /* 475 */ "PlusColonToken", + /* 476 */ "PortDeclaration", + /* 477 */ "PortDeclarationGroup", + /* 478 */ "PortDeclarationGroupGroup", + /* 479 */ "PortDeclarationGroupList", + /* 480 */ "PortDeclarationItem", + /* 481 */ "PortDeclarationItemGroup", + /* 482 */ "PortDeclarationItemOpt", + /* 483 */ "PortDeclarationList", + /* 484 */ "PortDeclarationListList", + /* 485 */ "PortDeclarationListOpt", + /* 486 */ "PortDeclarationOpt", + /* 487 */ "Pub", + /* 488 */ "PubTerm", + /* 489 */ "PubToken", + /* 490 */ "QuoteLBrace", + /* 491 */ "QuoteLBraceTerm", + /* 492 */ "QuoteLBraceToken", + /* 493 */ "RAngle", + /* 494 */ "RAngleTerm", + /* 495 */ "RAngleToken", + /* 496 */ "RBrace", + /* 497 */ "RBraceTerm", + /* 498 */ "RBraceToken", + /* 499 */ "RBracket", + /* 500 */ "RBracketTerm", + /* 501 */ "RBracketToken", + /* 502 */ "RParen", + /* 503 */ "RParenTerm", + /* 504 */ "RParenToken", + /* 505 */ "Range", + /* 506 */ "RangeItem", + /* 507 */ "RangeList", + /* 508 */ "RangeListList", + /* 509 */ "RangeListOpt", + /* 510 */ "RangeOperator", + /* 511 */ "RangeOpt", + /* 512 */ "RealNumber", + /* 513 */ "Ref", + /* 514 */ "RefTerm", + /* 515 */ "RefToken", + /* 516 */ "Repeat", + /* 517 */ "RepeatTerm", + /* 518 */ "RepeatToken", + /* 519 */ "Reset", + /* 520 */ "ResetAsyncHigh", + /* 521 */ "ResetAsyncHighTerm", + /* 522 */ "ResetAsyncHighToken", + /* 523 */ "ResetAsyncLow", + /* 524 */ "ResetAsyncLowTerm", + /* 525 */ "ResetAsyncLowToken", + /* 526 */ "ResetSyncHigh", + /* 527 */ "ResetSyncHighTerm", + /* 528 */ "ResetSyncHighToken", + /* 529 */ "ResetSyncLow", + /* 530 */ "ResetSyncLowTerm", + /* 531 */ "ResetSyncLowToken", + /* 532 */ "ResetTerm", + /* 533 */ "ResetToken", + /* 534 */ "Return", + /* 535 */ "ReturnStatement", + /* 536 */ "ReturnTerm", + /* 537 */ "ReturnToken", + /* 538 */ "ScalarType", + /* 539 */ "ScalarTypeGroup", + /* 540 */ "ScalarTypeList", + /* 541 */ "ScopedIdentifier", + /* 542 */ "ScopedIdentifierGroup", + /* 543 */ "ScopedIdentifierList", + /* 544 */ "ScopedIdentifierOpt", + /* 545 */ "ScopedIdentifierOpt0", + /* 546 */ "Select", + /* 547 */ "SelectOperator", + /* 548 */ "SelectOpt", + /* 549 */ "Semicolon", + /* 550 */ "SemicolonTerm", + /* 551 */ "SemicolonToken", + /* 552 */ "Signed", + /* 553 */ "SignedTerm", + /* 554 */ "SignedToken", + /* 555 */ "Star", + /* 556 */ "StarTerm", + /* 557 */ "StarToken", + /* 558 */ "Start", + /* 559 */ "StartToken", + /* 560 */ "Statement", + /* 561 */ "Step", + /* 562 */ "StepTerm", + /* 563 */ "StepToken", + /* 564 */ "Strin", + /* 565 */ "StringLiteral", + /* 566 */ "StringLiteralTerm", + /* 567 */ "StringLiteralToken", + /* 568 */ "StringTerm", + /* 569 */ "StringToken", + /* 570 */ "Struct", + /* 571 */ "StructTerm", + /* 572 */ "StructToken", + /* 573 */ "StructUnion", + /* 574 */ "StructUnionDeclaration", + /* 575 */ "StructUnionDeclarationOpt", + /* 576 */ "StructUnionGroup", + /* 577 */ "StructUnionGroupGroup", + /* 578 */ "StructUnionGroupList", + /* 579 */ "StructUnionItem", + /* 580 */ "StructUnionList", + /* 581 */ "StructUnionListList", + /* 582 */ "StructUnionListOpt", + /* 583 */ "Tri", + /* 584 */ "TriTerm", + /* 585 */ "TriToken", + /* 586 */ "Type", + /* 587 */ "TypeDefDeclaration", + /* 588 */ "TypeExpression", + /* 589 */ "TypeModifier", + /* 590 */ "TypeTerm", + /* 591 */ "TypeToken", + /* 592 */ "U32", + /* 593 */ "U32Term", + /* 594 */ "U32Token", + /* 595 */ "U64", + /* 596 */ "U64Term", + /* 597 */ "U64Token", + /* 598 */ "UnaryOperator", + /* 599 */ "UnaryOperatorTerm", + /* 600 */ "UnaryOperatorToken", + /* 601 */ "Union", + /* 602 */ "UnionTerm", + /* 603 */ "UnionToken", + /* 604 */ "Var", + /* 605 */ "VarDeclaration", + /* 606 */ "VarTerm", + /* 607 */ "VarToken", + /* 608 */ "VariableType", + /* 609 */ "VariableTypeGroup", + /* 610 */ "VariableTypeOpt", + /* 611 */ "Veryl", + /* 612 */ "VerylList", + /* 613 */ "Width", + /* 614 */ "WidthList", + /* 615 */ "WithGenericArgument", + /* 616 */ "WithGenericArgumentItem", + /* 617 */ "WithGenericArgumentList", + /* 618 */ "WithGenericArgumentListList", + /* 619 */ "WithGenericArgumentListOpt", + /* 620 */ "WithGenericParameter", + /* 621 */ "WithGenericParameterItem", + /* 622 */ "WithGenericParameterList", + /* 623 */ "WithGenericParameterListList", + /* 624 */ "WithGenericParameterListOpt", + /* 625 */ "WithParameter", + /* 626 */ "WithParameterGroup", + /* 627 */ "WithParameterGroupGroup", + /* 628 */ "WithParameterGroupList", + /* 629 */ "WithParameterItem", + /* 630 */ "WithParameterItemGroup", + /* 631 */ "WithParameterItemGroup0", + /* 632 */ "WithParameterList", + /* 633 */ "WithParameterListList", + /* 634 */ "WithParameterListOpt", + /* 635 */ "WithParameterOpt", ]; -pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ +pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 636] = &[ /* 0 - "AllBit" */ LookaheadDFA { - prod0: 224, + prod0: 226, transitions: &[], k: 0, }, @@ -1025,19 +1153,19 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ }, /* 2 - "AllBitToken" */ LookaheadDFA { - prod0: 117, + prod0: 118, transitions: &[], k: 0, }, /* 3 - "AlwaysComb" */ LookaheadDFA { - prod0: 260, + prod0: 263, transitions: &[], k: 0, }, /* 4 - "AlwaysCombDeclaration" */ LookaheadDFA { - prod0: 589, + prod0: 596, transitions: &[], k: 0, }, @@ -1045,46 +1173,46 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 591), - Trans(0, 52, 1, 590), - Trans(0, 64, 1, 590), - Trans(0, 68, 1, 590), - Trans(0, 69, 1, 590), - Trans(0, 79, 1, 590), - Trans(0, 98, 1, 590), - Trans(0, 99, 1, 590), - Trans(0, 110, 1, 590), - Trans(0, 111, 1, 590), + Trans(0, 43, 2, 598), + Trans(0, 53, 1, 597), + Trans(0, 65, 1, 597), + Trans(0, 69, 1, 597), + Trans(0, 70, 1, 597), + Trans(0, 80, 1, 597), + Trans(0, 99, 1, 597), + Trans(0, 100, 1, 597), + Trans(0, 111, 1, 597), + Trans(0, 112, 1, 597), ], k: 1, }, /* 6 - "AlwaysCombTerm" */ LookaheadDFA { - prod0: 42, + prod0: 43, transitions: &[], k: 0, }, /* 7 - "AlwaysCombToken" */ LookaheadDFA { - prod0: 153, + prod0: 155, transitions: &[], k: 0, }, /* 8 - "AlwaysFf" */ LookaheadDFA { - prod0: 261, + prod0: 264, transitions: &[], k: 0, }, /* 9 - "AlwaysFfClock" */ LookaheadDFA { - prod0: 587, + prod0: 594, transitions: &[], k: 0, }, /* 10 - "AlwaysFfDeclaration" */ LookaheadDFA { - prod0: 582, + prod0: 589, transitions: &[], k: 0, }, @@ -1092,58 +1220,58 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 584), - Trans(0, 52, 1, 583), - Trans(0, 64, 1, 583), - Trans(0, 68, 1, 583), - Trans(0, 69, 1, 583), - Trans(0, 79, 1, 583), - Trans(0, 98, 1, 583), - Trans(0, 99, 1, 583), - Trans(0, 110, 1, 583), - Trans(0, 111, 1, 583), + Trans(0, 43, 2, 591), + Trans(0, 53, 1, 590), + Trans(0, 65, 1, 590), + Trans(0, 69, 1, 590), + Trans(0, 70, 1, 590), + Trans(0, 80, 1, 590), + Trans(0, 99, 1, 590), + Trans(0, 100, 1, 590), + Trans(0, 111, 1, 590), + Trans(0, 112, 1, 590), ], k: 1, }, /* 12 - "AlwaysFfDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 585), Trans(0, 44, 2, 586)], + transitions: &[Trans(0, 31, 1, 592), Trans(0, 45, 2, 593)], k: 1, }, /* 13 - "AlwaysFfReset" */ LookaheadDFA { - prod0: 588, + prod0: 595, transitions: &[], k: 0, }, /* 14 - "AlwaysFfTerm" */ LookaheadDFA { - prod0: 43, + prod0: 44, transitions: &[], k: 0, }, /* 15 - "AlwaysFfToken" */ LookaheadDFA { - prod0: 154, + prod0: 156, transitions: &[], k: 0, }, /* 16 - "AnyTerm" */ LookaheadDFA { - prod0: 107, + prod0: 108, transitions: &[], k: 0, }, /* 17 - "ArgumentItem" */ LookaheadDFA { - prod0: 420, + prod0: 427, transitions: &[], k: 0, }, /* 18 - "ArgumentList" */ LookaheadDFA { - prod0: 415, + prod0: 422, transitions: &[], k: 0, }, @@ -1151,9 +1279,9 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 44, 8, -1), - Trans(1, 5, 7, -1), + Trans(0, 31, 1, -1), + Trans(0, 45, 9, -1), + Trans(1, 5, 8, -1), Trans(1, 6, 2, -1), Trans(1, 7, 2, -1), Trans(1, 8, 2, -1), @@ -1165,554 +1293,575 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(1, 25, 4, -1), Trans(1, 26, 4, -1), Trans(1, 27, 4, -1), - Trans(1, 37, 5, -1), - Trans(1, 38, 4, -1), - Trans(1, 40, 4, -1), - Trans(1, 44, 22, -1), - Trans(1, 52, 4, -1), - Trans(1, 69, 4, -1), - Trans(1, 75, 4, -1), - Trans(1, 82, 2, -1), - Trans(1, 85, 2, -1), - Trans(1, 87, 4, -1), - Trans(1, 110, 6, -1), + Trans(1, 38, 5, -1), + Trans(1, 39, 4, -1), + Trans(1, 41, 4, -1), + Trans(1, 45, 23, -1), + Trans(1, 53, 4, -1), + Trans(1, 70, 4, -1), + Trans(1, 76, 4, -1), + Trans(1, 83, 2, -1), + Trans(1, 86, 2, -1), + Trans(1, 88, 4, -1), Trans(1, 111, 6, -1), - Trans(2, 5, 3, 416), - Trans(2, 16, 3, 416), - Trans(2, 17, 3, 416), - Trans(2, 18, 3, 416), - Trans(2, 19, 3, 416), - Trans(2, 20, 3, 416), - Trans(2, 21, 3, 416), - Trans(2, 22, 3, 416), - Trans(2, 23, 3, 416), - Trans(2, 24, 3, 416), - Trans(2, 25, 3, 416), - Trans(2, 26, 3, 416), - Trans(2, 30, 3, 416), - Trans(2, 44, 3, 416), - Trans(2, 46, 3, 416), - Trans(2, 50, 3, 416), - Trans(4, 5, 3, 416), - Trans(4, 6, 3, 416), - Trans(4, 7, 3, 416), - Trans(4, 8, 3, 416), - Trans(4, 9, 3, 416), - Trans(4, 10, 3, 416), - Trans(4, 11, 3, 416), - Trans(4, 18, 3, 416), - Trans(4, 24, 3, 416), - Trans(4, 25, 3, 416), - Trans(4, 26, 3, 416), - Trans(4, 27, 3, 416), - Trans(4, 37, 3, 416), - Trans(4, 38, 3, 416), - Trans(4, 40, 3, 416), - Trans(4, 52, 3, 416), - Trans(4, 69, 3, 416), - Trans(4, 75, 3, 416), - Trans(4, 82, 3, 416), - Trans(4, 85, 3, 416), - Trans(4, 87, 3, 416), - Trans(4, 110, 3, 416), - Trans(4, 111, 3, 416), - Trans(5, 5, 3, 416), - Trans(5, 6, 3, 416), - Trans(5, 7, 3, 416), - Trans(5, 8, 3, 416), - Trans(5, 9, 3, 416), - Trans(5, 10, 3, 416), - Trans(5, 11, 3, 416), - Trans(5, 18, 3, 416), - Trans(5, 24, 3, 416), - Trans(5, 25, 3, 416), - Trans(5, 26, 3, 416), - Trans(5, 27, 3, 416), - Trans(5, 37, 3, 416), - Trans(5, 38, 3, 416), - Trans(5, 40, 3, 416), - Trans(5, 52, 3, 416), - Trans(5, 56, 3, 416), - Trans(5, 69, 3, 416), - Trans(5, 75, 3, 416), - Trans(5, 82, 3, 416), - Trans(5, 85, 3, 416), - Trans(5, 87, 3, 416), - Trans(5, 110, 3, 416), - Trans(5, 111, 3, 416), - Trans(6, 5, 3, 416), - Trans(6, 16, 3, 416), - Trans(6, 17, 3, 416), - Trans(6, 18, 3, 416), - Trans(6, 19, 3, 416), - Trans(6, 20, 3, 416), - Trans(6, 21, 3, 416), - Trans(6, 22, 3, 416), - Trans(6, 23, 3, 416), - Trans(6, 24, 3, 416), - Trans(6, 25, 3, 416), - Trans(6, 26, 3, 416), - Trans(6, 28, 3, 416), - Trans(6, 30, 3, 416), - Trans(6, 33, 3, 416), - Trans(6, 39, 3, 416), - Trans(6, 40, 3, 416), - Trans(6, 44, 3, 416), - Trans(6, 46, 3, 416), - Trans(6, 50, 3, 416), - Trans(7, 6, 3, 416), - Trans(7, 7, 3, 416), - Trans(7, 8, 3, 416), - Trans(7, 9, 3, 416), - Trans(7, 10, 3, 416), - Trans(7, 11, 3, 416), - Trans(7, 18, 3, 416), - Trans(7, 24, 3, 416), - Trans(7, 25, 3, 416), - Trans(7, 26, 3, 416), - Trans(7, 27, 3, 416), - Trans(7, 37, 3, 416), - Trans(7, 38, 3, 416), - Trans(7, 40, 3, 416), - Trans(7, 44, 21, 417), - Trans(7, 52, 3, 416), - Trans(7, 69, 3, 416), - Trans(7, 75, 3, 416), - Trans(7, 82, 3, 416), - Trans(7, 85, 3, 416), - Trans(7, 87, 3, 416), - Trans(7, 110, 3, 416), - Trans(7, 111, 3, 416), - Trans(8, 5, 9, -1), - Trans(8, 12, 10, -1), - Trans(8, 14, 10, -1), - Trans(8, 16, 10, -1), - Trans(8, 17, 10, -1), - Trans(8, 18, 10, -1), - Trans(8, 19, 10, -1), - Trans(8, 20, 10, -1), - Trans(8, 21, 10, -1), - Trans(8, 22, 10, -1), - Trans(8, 23, 10, -1), - Trans(8, 24, 10, -1), - Trans(8, 25, 10, -1), - Trans(8, 26, 10, -1), - Trans(8, 29, 11, -1), - Trans(8, 30, 12, -1), - Trans(8, 31, 10, -1), - Trans(8, 32, 10, -1), - Trans(8, 38, 13, -1), - Trans(8, 41, 14, -1), - Trans(8, 42, 15, -1), - Trans(8, 43, 16, -1), - Trans(8, 44, 17, -1), - Trans(8, 45, 18, -1), - Trans(8, 46, 10, -1), - Trans(8, 50, 19, -1), - Trans(8, 92, 10, -1), - Trans(8, 101, 20, -1), - Trans(9, 12, 21, 417), - Trans(9, 14, 21, 417), - Trans(9, 16, 21, 417), - Trans(9, 17, 21, 417), - Trans(9, 18, 21, 417), - Trans(9, 19, 21, 417), - Trans(9, 20, 21, 417), - Trans(9, 21, 21, 417), - Trans(9, 22, 21, 417), - Trans(9, 23, 21, 417), - Trans(9, 24, 21, 417), - Trans(9, 25, 21, 417), - Trans(9, 26, 21, 417), - Trans(9, 29, 21, 417), - Trans(9, 30, 21, 417), - Trans(9, 31, 21, 417), - Trans(9, 32, 21, 417), - Trans(9, 38, 21, 417), - Trans(9, 41, 21, 417), - Trans(9, 42, 21, 417), - Trans(9, 43, 21, 417), - Trans(9, 44, 21, 417), - Trans(9, 45, 21, 417), - Trans(9, 46, 21, 417), - Trans(9, 50, 21, 417), - Trans(9, 92, 21, 417), - Trans(9, 101, 21, 417), - Trans(10, 5, 21, 417), - Trans(10, 6, 21, 417), - Trans(10, 7, 21, 417), - Trans(10, 8, 21, 417), - Trans(10, 9, 21, 417), - Trans(10, 10, 21, 417), - Trans(10, 11, 21, 417), - Trans(10, 18, 21, 417), - Trans(10, 24, 21, 417), - Trans(10, 25, 21, 417), - Trans(10, 26, 21, 417), - Trans(10, 27, 21, 417), - Trans(10, 37, 21, 417), - Trans(10, 38, 21, 417), - Trans(10, 40, 21, 417), - Trans(10, 52, 21, 417), - Trans(10, 69, 21, 417), - Trans(10, 75, 21, 417), - Trans(10, 82, 21, 417), - Trans(10, 85, 21, 417), - Trans(10, 87, 21, 417), - Trans(10, 110, 21, 417), - Trans(10, 111, 21, 417), - Trans(11, 5, 21, 417), - Trans(11, 6, 21, 417), - Trans(11, 7, 21, 417), - Trans(11, 8, 21, 417), - Trans(11, 9, 21, 417), - Trans(11, 10, 21, 417), - Trans(11, 11, 21, 417), - Trans(11, 18, 21, 417), - Trans(11, 24, 21, 417), - Trans(11, 25, 21, 417), - Trans(11, 26, 21, 417), - Trans(11, 27, 21, 417), - Trans(11, 37, 21, 417), - Trans(11, 38, 21, 417), - Trans(11, 40, 21, 417), - Trans(11, 52, 21, 417), - Trans(11, 64, 21, 417), - Trans(11, 68, 21, 417), - Trans(11, 69, 21, 417), - Trans(11, 75, 21, 417), - Trans(11, 79, 21, 417), - Trans(11, 82, 21, 417), - Trans(11, 85, 21, 417), - Trans(11, 87, 21, 417), - Trans(11, 98, 21, 417), - Trans(11, 99, 21, 417), - Trans(11, 110, 21, 417), - Trans(11, 111, 21, 417), - Trans(12, 5, 21, 417), - Trans(12, 6, 21, 417), - Trans(12, 7, 21, 417), - Trans(12, 8, 21, 417), - Trans(12, 9, 21, 417), - Trans(12, 10, 21, 417), - Trans(12, 11, 21, 417), - Trans(12, 18, 21, 417), - Trans(12, 24, 21, 417), - Trans(12, 25, 21, 417), - Trans(12, 26, 21, 417), - Trans(12, 27, 21, 417), - Trans(12, 35, 21, 417), - Trans(12, 37, 21, 417), - Trans(12, 38, 21, 417), - Trans(12, 40, 21, 417), - Trans(12, 42, 21, 417), - Trans(12, 44, 21, 417), - Trans(12, 52, 21, 417), - Trans(12, 56, 21, 417), - Trans(12, 69, 21, 417), - Trans(12, 75, 21, 417), - Trans(12, 80, 21, 417), - Trans(12, 82, 21, 417), - Trans(12, 85, 21, 417), - Trans(12, 87, 21, 417), - Trans(12, 89, 21, 417), - Trans(12, 110, 21, 417), - Trans(12, 111, 21, 417), - Trans(13, 5, 21, 417), - Trans(13, 6, 21, 417), - Trans(13, 7, 21, 417), - Trans(13, 8, 21, 417), - Trans(13, 9, 21, 417), - Trans(13, 10, 21, 417), - Trans(13, 11, 21, 417), - Trans(13, 18, 21, 417), - Trans(13, 24, 21, 417), - Trans(13, 25, 21, 417), - Trans(13, 26, 21, 417), - Trans(13, 27, 21, 417), - Trans(13, 29, 21, 417), - Trans(13, 35, 21, 417), - Trans(13, 37, 21, 417), - Trans(13, 38, 21, 417), - Trans(13, 40, 21, 417), - Trans(13, 42, 21, 417), - Trans(13, 47, 21, 417), - Trans(13, 48, 21, 417), - Trans(13, 49, 21, 417), - Trans(13, 52, 21, 417), - Trans(13, 56, 21, 417), - Trans(13, 59, 21, 417), - Trans(13, 63, 21, 417), - Trans(13, 64, 21, 417), - Trans(13, 65, 21, 417), - Trans(13, 68, 21, 417), - Trans(13, 69, 21, 417), - Trans(13, 70, 21, 417), - Trans(13, 72, 21, 417), - Trans(13, 75, 21, 417), - Trans(13, 76, 21, 417), - Trans(13, 79, 21, 417), - Trans(13, 80, 21, 417), - Trans(13, 82, 21, 417), - Trans(13, 83, 21, 417), - Trans(13, 85, 21, 417), - Trans(13, 87, 21, 417), - Trans(13, 98, 21, 417), - Trans(13, 99, 21, 417), - Trans(13, 103, 21, 417), - Trans(13, 105, 21, 417), - Trans(13, 108, 21, 417), - Trans(13, 109, 21, 417), - Trans(13, 110, 21, 417), - Trans(13, 111, 21, 417), - Trans(14, 5, 21, 417), - Trans(14, 30, 21, 417), - Trans(14, 34, 21, 417), - Trans(14, 38, 21, 417), - Trans(14, 39, 21, 417), - Trans(14, 42, 21, 417), - Trans(14, 44, 21, 417), - Trans(14, 45, 21, 417), - Trans(14, 78, 21, 417), - Trans(15, 5, 21, 417), - Trans(15, 12, 21, 417), - Trans(15, 14, 21, 417), - Trans(15, 16, 21, 417), - Trans(15, 17, 21, 417), - Trans(15, 18, 21, 417), - Trans(15, 19, 21, 417), - Trans(15, 20, 21, 417), - Trans(15, 21, 21, 417), - Trans(15, 22, 21, 417), - Trans(15, 23, 21, 417), - Trans(15, 24, 21, 417), - Trans(15, 25, 21, 417), - Trans(15, 26, 21, 417), - Trans(15, 29, 21, 417), - Trans(15, 30, 21, 417), - Trans(15, 31, 21, 417), - Trans(15, 32, 21, 417), - Trans(15, 35, 21, 417), - Trans(15, 38, 21, 417), - Trans(15, 41, 21, 417), - Trans(15, 42, 21, 417), - Trans(15, 43, 21, 417), - Trans(15, 44, 21, 417), - Trans(15, 45, 21, 417), - Trans(15, 46, 21, 417), - Trans(15, 47, 21, 417), - Trans(15, 48, 21, 417), - Trans(15, 49, 21, 417), - Trans(15, 50, 21, 417), - Trans(15, 57, 21, 417), - Trans(15, 59, 21, 417), - Trans(15, 60, 21, 417), - Trans(15, 63, 21, 417), - Trans(15, 64, 21, 417), - Trans(15, 65, 21, 417), - Trans(15, 69, 21, 417), - Trans(15, 70, 21, 417), - Trans(15, 72, 21, 417), - Trans(15, 76, 21, 417), - Trans(15, 79, 21, 417), - Trans(15, 80, 21, 417), - Trans(15, 83, 21, 417), - Trans(15, 92, 21, 417), - Trans(15, 101, 21, 417), - Trans(15, 103, 21, 417), - Trans(15, 105, 21, 417), - Trans(15, 108, 21, 417), - Trans(15, 109, 21, 417), - Trans(16, 5, 21, 417), - Trans(16, 12, 21, 417), - Trans(16, 14, 21, 417), - Trans(16, 15, 21, 417), - Trans(16, 16, 21, 417), - Trans(16, 17, 21, 417), - Trans(16, 18, 21, 417), - Trans(16, 19, 21, 417), - Trans(16, 20, 21, 417), - Trans(16, 21, 21, 417), - Trans(16, 22, 21, 417), - Trans(16, 23, 21, 417), - Trans(16, 24, 21, 417), - Trans(16, 25, 21, 417), - Trans(16, 26, 21, 417), - Trans(16, 29, 21, 417), - Trans(16, 30, 21, 417), - Trans(16, 31, 21, 417), - Trans(16, 32, 21, 417), - Trans(16, 33, 21, 417), - Trans(16, 34, 21, 417), - Trans(16, 35, 21, 417), - Trans(16, 38, 21, 417), - Trans(16, 39, 21, 417), - Trans(16, 40, 21, 417), - Trans(16, 41, 21, 417), - Trans(16, 42, 21, 417), - Trans(16, 43, 21, 417), - Trans(16, 44, 21, 417), - Trans(16, 45, 21, 417), - Trans(16, 46, 21, 417), - Trans(16, 50, 21, 417), - Trans(16, 92, 21, 417), - Trans(16, 101, 21, 417), - Trans(17, 5, 21, 417), - Trans(17, 12, 21, 417), - Trans(17, 14, 21, 417), - Trans(17, 16, 21, 417), - Trans(17, 17, 21, 417), - Trans(17, 18, 21, 417), - Trans(17, 19, 21, 417), - Trans(17, 20, 21, 417), - Trans(17, 21, 21, 417), - Trans(17, 22, 21, 417), - Trans(17, 23, 21, 417), - Trans(17, 24, 21, 417), - Trans(17, 25, 21, 417), - Trans(17, 26, 21, 417), - Trans(17, 29, 21, 417), - Trans(17, 30, 21, 417), - Trans(17, 31, 21, 417), - Trans(17, 32, 21, 417), - Trans(17, 38, 21, 417), - Trans(17, 40, 21, 417), - Trans(17, 41, 21, 417), - Trans(17, 42, 21, 417), - Trans(17, 43, 21, 417), - Trans(17, 44, 21, 417), - Trans(17, 45, 21, 417), - Trans(17, 46, 21, 417), - Trans(17, 50, 21, 417), - Trans(17, 92, 21, 417), - Trans(17, 101, 21, 417), - Trans(18, 5, 21, 417), - Trans(18, 6, 21, 417), - Trans(18, 7, 21, 417), - Trans(18, 8, 21, 417), - Trans(18, 9, 21, 417), - Trans(18, 10, 21, 417), - Trans(18, 11, 21, 417), - Trans(18, 18, 21, 417), - Trans(18, 24, 21, 417), - Trans(18, 25, 21, 417), - Trans(18, 26, 21, 417), - Trans(18, 27, 21, 417), - Trans(18, 29, 21, 417), - Trans(18, 35, 21, 417), - Trans(18, 37, 21, 417), - Trans(18, 38, 21, 417), - Trans(18, 40, 21, 417), - Trans(18, 42, 21, 417), - Trans(18, 47, 21, 417), - Trans(18, 48, 21, 417), - Trans(18, 49, 21, 417), - Trans(18, 52, 21, 417), - Trans(18, 56, 21, 417), - Trans(18, 59, 21, 417), - Trans(18, 60, 21, 417), - Trans(18, 63, 21, 417), - Trans(18, 64, 21, 417), - Trans(18, 65, 21, 417), - Trans(18, 68, 21, 417), - Trans(18, 69, 21, 417), - Trans(18, 70, 21, 417), - Trans(18, 72, 21, 417), - Trans(18, 75, 21, 417), - Trans(18, 76, 21, 417), - Trans(18, 79, 21, 417), - Trans(18, 80, 21, 417), - Trans(18, 82, 21, 417), - Trans(18, 83, 21, 417), - Trans(18, 85, 21, 417), - Trans(18, 87, 21, 417), - Trans(18, 98, 21, 417), - Trans(18, 99, 21, 417), - Trans(18, 103, 21, 417), - Trans(18, 105, 21, 417), - Trans(18, 108, 21, 417), - Trans(18, 109, 21, 417), - Trans(18, 110, 21, 417), - Trans(18, 111, 21, 417), - Trans(19, 5, 21, 417), - Trans(19, 110, 21, 417), - Trans(19, 111, 21, 417), - Trans(20, 5, 21, 417), - Trans(20, 6, 21, 417), - Trans(20, 7, 21, 417), - Trans(20, 8, 21, 417), - Trans(20, 9, 21, 417), - Trans(20, 10, 21, 417), - Trans(20, 11, 21, 417), - Trans(20, 15, 21, 417), - Trans(20, 18, 21, 417), - Trans(20, 24, 21, 417), - Trans(20, 25, 21, 417), - Trans(20, 26, 21, 417), - Trans(20, 27, 21, 417), - Trans(20, 37, 21, 417), - Trans(20, 38, 21, 417), - Trans(20, 40, 21, 417), - Trans(20, 52, 21, 417), - Trans(20, 69, 21, 417), - Trans(20, 75, 21, 417), - Trans(20, 82, 21, 417), - Trans(20, 85, 21, 417), - Trans(20, 87, 21, 417), - Trans(20, 110, 21, 417), - Trans(20, 111, 21, 417), - Trans(22, 5, 21, 417), - Trans(22, 12, 21, 417), - Trans(22, 14, 21, 417), - Trans(22, 16, 21, 417), - Trans(22, 17, 21, 417), - Trans(22, 18, 21, 417), - Trans(22, 19, 21, 417), - Trans(22, 20, 21, 417), - Trans(22, 21, 21, 417), - Trans(22, 22, 21, 417), - Trans(22, 23, 21, 417), - Trans(22, 24, 21, 417), - Trans(22, 25, 21, 417), - Trans(22, 26, 21, 417), - Trans(22, 29, 21, 417), - Trans(22, 30, 21, 417), - Trans(22, 31, 21, 417), - Trans(22, 32, 21, 417), - Trans(22, 38, 21, 417), - Trans(22, 41, 21, 417), - Trans(22, 42, 21, 417), - Trans(22, 43, 21, 417), - Trans(22, 44, 21, 417), - Trans(22, 45, 21, 417), - Trans(22, 46, 21, 417), - Trans(22, 50, 21, 417), - Trans(22, 92, 21, 417), - Trans(22, 101, 21, 417), + Trans(1, 112, 7, -1), + Trans(2, 5, 3, 423), + Trans(2, 16, 3, 423), + Trans(2, 17, 3, 423), + Trans(2, 18, 3, 423), + Trans(2, 19, 3, 423), + Trans(2, 20, 3, 423), + Trans(2, 21, 3, 423), + Trans(2, 22, 3, 423), + Trans(2, 23, 3, 423), + Trans(2, 24, 3, 423), + Trans(2, 25, 3, 423), + Trans(2, 26, 3, 423), + Trans(2, 31, 3, 423), + Trans(2, 45, 3, 423), + Trans(2, 47, 3, 423), + Trans(2, 51, 3, 423), + Trans(4, 5, 3, 423), + Trans(4, 6, 3, 423), + Trans(4, 7, 3, 423), + Trans(4, 8, 3, 423), + Trans(4, 9, 3, 423), + Trans(4, 10, 3, 423), + Trans(4, 11, 3, 423), + Trans(4, 18, 3, 423), + Trans(4, 24, 3, 423), + Trans(4, 25, 3, 423), + Trans(4, 26, 3, 423), + Trans(4, 27, 3, 423), + Trans(4, 38, 3, 423), + Trans(4, 39, 3, 423), + Trans(4, 41, 3, 423), + Trans(4, 53, 3, 423), + Trans(4, 70, 3, 423), + Trans(4, 76, 3, 423), + Trans(4, 83, 3, 423), + Trans(4, 86, 3, 423), + Trans(4, 88, 3, 423), + Trans(4, 111, 3, 423), + Trans(4, 112, 3, 423), + Trans(5, 5, 3, 423), + Trans(5, 6, 3, 423), + Trans(5, 7, 3, 423), + Trans(5, 8, 3, 423), + Trans(5, 9, 3, 423), + Trans(5, 10, 3, 423), + Trans(5, 11, 3, 423), + Trans(5, 18, 3, 423), + Trans(5, 24, 3, 423), + Trans(5, 25, 3, 423), + Trans(5, 26, 3, 423), + Trans(5, 27, 3, 423), + Trans(5, 38, 3, 423), + Trans(5, 39, 3, 423), + Trans(5, 41, 3, 423), + Trans(5, 53, 3, 423), + Trans(5, 57, 3, 423), + Trans(5, 70, 3, 423), + Trans(5, 76, 3, 423), + Trans(5, 83, 3, 423), + Trans(5, 86, 3, 423), + Trans(5, 88, 3, 423), + Trans(5, 111, 3, 423), + Trans(5, 112, 3, 423), + Trans(6, 5, 3, 423), + Trans(6, 16, 3, 423), + Trans(6, 17, 3, 423), + Trans(6, 18, 3, 423), + Trans(6, 19, 3, 423), + Trans(6, 20, 3, 423), + Trans(6, 21, 3, 423), + Trans(6, 22, 3, 423), + Trans(6, 23, 3, 423), + Trans(6, 24, 3, 423), + Trans(6, 25, 3, 423), + Trans(6, 26, 3, 423), + Trans(6, 29, 3, 423), + Trans(6, 31, 3, 423), + Trans(6, 34, 3, 423), + Trans(6, 40, 3, 423), + Trans(6, 41, 3, 423), + Trans(6, 45, 3, 423), + Trans(6, 47, 3, 423), + Trans(6, 51, 3, 423), + Trans(7, 5, 3, 423), + Trans(7, 16, 3, 423), + Trans(7, 17, 3, 423), + Trans(7, 18, 3, 423), + Trans(7, 19, 3, 423), + Trans(7, 20, 3, 423), + Trans(7, 21, 3, 423), + Trans(7, 22, 3, 423), + Trans(7, 23, 3, 423), + Trans(7, 24, 3, 423), + Trans(7, 25, 3, 423), + Trans(7, 26, 3, 423), + Trans(7, 28, 3, 423), + Trans(7, 29, 3, 423), + Trans(7, 31, 3, 423), + Trans(7, 34, 3, 423), + Trans(7, 40, 3, 423), + Trans(7, 41, 3, 423), + Trans(7, 45, 3, 423), + Trans(7, 47, 3, 423), + Trans(7, 51, 3, 423), + Trans(8, 6, 3, 423), + Trans(8, 7, 3, 423), + Trans(8, 8, 3, 423), + Trans(8, 9, 3, 423), + Trans(8, 10, 3, 423), + Trans(8, 11, 3, 423), + Trans(8, 18, 3, 423), + Trans(8, 24, 3, 423), + Trans(8, 25, 3, 423), + Trans(8, 26, 3, 423), + Trans(8, 27, 3, 423), + Trans(8, 38, 3, 423), + Trans(8, 39, 3, 423), + Trans(8, 41, 3, 423), + Trans(8, 45, 22, 424), + Trans(8, 53, 3, 423), + Trans(8, 70, 3, 423), + Trans(8, 76, 3, 423), + Trans(8, 83, 3, 423), + Trans(8, 86, 3, 423), + Trans(8, 88, 3, 423), + Trans(8, 111, 3, 423), + Trans(8, 112, 3, 423), + Trans(9, 5, 10, -1), + Trans(9, 12, 11, -1), + Trans(9, 14, 11, -1), + Trans(9, 16, 11, -1), + Trans(9, 17, 11, -1), + Trans(9, 18, 11, -1), + Trans(9, 19, 11, -1), + Trans(9, 20, 11, -1), + Trans(9, 21, 11, -1), + Trans(9, 22, 11, -1), + Trans(9, 23, 11, -1), + Trans(9, 24, 11, -1), + Trans(9, 25, 11, -1), + Trans(9, 26, 11, -1), + Trans(9, 30, 12, -1), + Trans(9, 31, 13, -1), + Trans(9, 32, 11, -1), + Trans(9, 33, 11, -1), + Trans(9, 39, 14, -1), + Trans(9, 42, 15, -1), + Trans(9, 43, 16, -1), + Trans(9, 44, 17, -1), + Trans(9, 45, 18, -1), + Trans(9, 46, 19, -1), + Trans(9, 47, 11, -1), + Trans(9, 51, 20, -1), + Trans(9, 93, 11, -1), + Trans(9, 102, 21, -1), + Trans(10, 12, 22, 424), + Trans(10, 14, 22, 424), + Trans(10, 16, 22, 424), + Trans(10, 17, 22, 424), + Trans(10, 18, 22, 424), + Trans(10, 19, 22, 424), + Trans(10, 20, 22, 424), + Trans(10, 21, 22, 424), + Trans(10, 22, 22, 424), + Trans(10, 23, 22, 424), + Trans(10, 24, 22, 424), + Trans(10, 25, 22, 424), + Trans(10, 26, 22, 424), + Trans(10, 30, 22, 424), + Trans(10, 31, 22, 424), + Trans(10, 32, 22, 424), + Trans(10, 33, 22, 424), + Trans(10, 39, 22, 424), + Trans(10, 42, 22, 424), + Trans(10, 43, 22, 424), + Trans(10, 44, 22, 424), + Trans(10, 45, 22, 424), + Trans(10, 46, 22, 424), + Trans(10, 47, 22, 424), + Trans(10, 51, 22, 424), + Trans(10, 93, 22, 424), + Trans(10, 102, 22, 424), + Trans(11, 5, 22, 424), + Trans(11, 6, 22, 424), + Trans(11, 7, 22, 424), + Trans(11, 8, 22, 424), + Trans(11, 9, 22, 424), + Trans(11, 10, 22, 424), + Trans(11, 11, 22, 424), + Trans(11, 18, 22, 424), + Trans(11, 24, 22, 424), + Trans(11, 25, 22, 424), + Trans(11, 26, 22, 424), + Trans(11, 27, 22, 424), + Trans(11, 38, 22, 424), + Trans(11, 39, 22, 424), + Trans(11, 41, 22, 424), + Trans(11, 53, 22, 424), + Trans(11, 70, 22, 424), + Trans(11, 76, 22, 424), + Trans(11, 83, 22, 424), + Trans(11, 86, 22, 424), + Trans(11, 88, 22, 424), + Trans(11, 111, 22, 424), + Trans(11, 112, 22, 424), + Trans(12, 5, 22, 424), + Trans(12, 6, 22, 424), + Trans(12, 7, 22, 424), + Trans(12, 8, 22, 424), + Trans(12, 9, 22, 424), + Trans(12, 10, 22, 424), + Trans(12, 11, 22, 424), + Trans(12, 18, 22, 424), + Trans(12, 24, 22, 424), + Trans(12, 25, 22, 424), + Trans(12, 26, 22, 424), + Trans(12, 27, 22, 424), + Trans(12, 38, 22, 424), + Trans(12, 39, 22, 424), + Trans(12, 41, 22, 424), + Trans(12, 53, 22, 424), + Trans(12, 65, 22, 424), + Trans(12, 69, 22, 424), + Trans(12, 70, 22, 424), + Trans(12, 76, 22, 424), + Trans(12, 80, 22, 424), + Trans(12, 83, 22, 424), + Trans(12, 86, 22, 424), + Trans(12, 88, 22, 424), + Trans(12, 99, 22, 424), + Trans(12, 100, 22, 424), + Trans(12, 111, 22, 424), + Trans(12, 112, 22, 424), + Trans(13, 5, 22, 424), + Trans(13, 6, 22, 424), + Trans(13, 7, 22, 424), + Trans(13, 8, 22, 424), + Trans(13, 9, 22, 424), + Trans(13, 10, 22, 424), + Trans(13, 11, 22, 424), + Trans(13, 18, 22, 424), + Trans(13, 24, 22, 424), + Trans(13, 25, 22, 424), + Trans(13, 26, 22, 424), + Trans(13, 27, 22, 424), + Trans(13, 36, 22, 424), + Trans(13, 38, 22, 424), + Trans(13, 39, 22, 424), + Trans(13, 41, 22, 424), + Trans(13, 43, 22, 424), + Trans(13, 45, 22, 424), + Trans(13, 53, 22, 424), + Trans(13, 57, 22, 424), + Trans(13, 70, 22, 424), + Trans(13, 76, 22, 424), + Trans(13, 81, 22, 424), + Trans(13, 83, 22, 424), + Trans(13, 86, 22, 424), + Trans(13, 88, 22, 424), + Trans(13, 90, 22, 424), + Trans(13, 111, 22, 424), + Trans(13, 112, 22, 424), + Trans(14, 5, 22, 424), + Trans(14, 6, 22, 424), + Trans(14, 7, 22, 424), + Trans(14, 8, 22, 424), + Trans(14, 9, 22, 424), + Trans(14, 10, 22, 424), + Trans(14, 11, 22, 424), + Trans(14, 18, 22, 424), + Trans(14, 24, 22, 424), + Trans(14, 25, 22, 424), + Trans(14, 26, 22, 424), + Trans(14, 27, 22, 424), + Trans(14, 30, 22, 424), + Trans(14, 36, 22, 424), + Trans(14, 38, 22, 424), + Trans(14, 39, 22, 424), + Trans(14, 41, 22, 424), + Trans(14, 43, 22, 424), + Trans(14, 48, 22, 424), + Trans(14, 49, 22, 424), + Trans(14, 50, 22, 424), + Trans(14, 53, 22, 424), + Trans(14, 57, 22, 424), + Trans(14, 60, 22, 424), + Trans(14, 64, 22, 424), + Trans(14, 65, 22, 424), + Trans(14, 66, 22, 424), + Trans(14, 69, 22, 424), + Trans(14, 70, 22, 424), + Trans(14, 71, 22, 424), + Trans(14, 73, 22, 424), + Trans(14, 76, 22, 424), + Trans(14, 77, 22, 424), + Trans(14, 80, 22, 424), + Trans(14, 81, 22, 424), + Trans(14, 83, 22, 424), + Trans(14, 84, 22, 424), + Trans(14, 86, 22, 424), + Trans(14, 88, 22, 424), + Trans(14, 99, 22, 424), + Trans(14, 100, 22, 424), + Trans(14, 104, 22, 424), + Trans(14, 106, 22, 424), + Trans(14, 109, 22, 424), + Trans(14, 110, 22, 424), + Trans(14, 111, 22, 424), + Trans(14, 112, 22, 424), + Trans(15, 5, 22, 424), + Trans(15, 31, 22, 424), + Trans(15, 35, 22, 424), + Trans(15, 39, 22, 424), + Trans(15, 40, 22, 424), + Trans(15, 43, 22, 424), + Trans(15, 45, 22, 424), + Trans(15, 46, 22, 424), + Trans(15, 79, 22, 424), + Trans(16, 5, 22, 424), + Trans(16, 12, 22, 424), + Trans(16, 14, 22, 424), + Trans(16, 16, 22, 424), + Trans(16, 17, 22, 424), + Trans(16, 18, 22, 424), + Trans(16, 19, 22, 424), + Trans(16, 20, 22, 424), + Trans(16, 21, 22, 424), + Trans(16, 22, 22, 424), + Trans(16, 23, 22, 424), + Trans(16, 24, 22, 424), + Trans(16, 25, 22, 424), + Trans(16, 26, 22, 424), + Trans(16, 30, 22, 424), + Trans(16, 31, 22, 424), + Trans(16, 32, 22, 424), + Trans(16, 33, 22, 424), + Trans(16, 36, 22, 424), + Trans(16, 39, 22, 424), + Trans(16, 42, 22, 424), + Trans(16, 43, 22, 424), + Trans(16, 44, 22, 424), + Trans(16, 45, 22, 424), + Trans(16, 46, 22, 424), + Trans(16, 47, 22, 424), + Trans(16, 48, 22, 424), + Trans(16, 49, 22, 424), + Trans(16, 50, 22, 424), + Trans(16, 51, 22, 424), + Trans(16, 58, 22, 424), + Trans(16, 60, 22, 424), + Trans(16, 61, 22, 424), + Trans(16, 64, 22, 424), + Trans(16, 65, 22, 424), + Trans(16, 66, 22, 424), + Trans(16, 70, 22, 424), + Trans(16, 71, 22, 424), + Trans(16, 73, 22, 424), + Trans(16, 77, 22, 424), + Trans(16, 80, 22, 424), + Trans(16, 81, 22, 424), + Trans(16, 84, 22, 424), + Trans(16, 93, 22, 424), + Trans(16, 102, 22, 424), + Trans(16, 104, 22, 424), + Trans(16, 106, 22, 424), + Trans(16, 109, 22, 424), + Trans(16, 110, 22, 424), + Trans(17, 5, 22, 424), + Trans(17, 12, 22, 424), + Trans(17, 14, 22, 424), + Trans(17, 15, 22, 424), + Trans(17, 16, 22, 424), + Trans(17, 17, 22, 424), + Trans(17, 18, 22, 424), + Trans(17, 19, 22, 424), + Trans(17, 20, 22, 424), + Trans(17, 21, 22, 424), + Trans(17, 22, 22, 424), + Trans(17, 23, 22, 424), + Trans(17, 24, 22, 424), + Trans(17, 25, 22, 424), + Trans(17, 26, 22, 424), + Trans(17, 30, 22, 424), + Trans(17, 31, 22, 424), + Trans(17, 32, 22, 424), + Trans(17, 33, 22, 424), + Trans(17, 34, 22, 424), + Trans(17, 35, 22, 424), + Trans(17, 36, 22, 424), + Trans(17, 39, 22, 424), + Trans(17, 40, 22, 424), + Trans(17, 41, 22, 424), + Trans(17, 42, 22, 424), + Trans(17, 43, 22, 424), + Trans(17, 44, 22, 424), + Trans(17, 45, 22, 424), + Trans(17, 46, 22, 424), + Trans(17, 47, 22, 424), + Trans(17, 51, 22, 424), + Trans(17, 93, 22, 424), + Trans(17, 102, 22, 424), + Trans(18, 5, 22, 424), + Trans(18, 12, 22, 424), + Trans(18, 14, 22, 424), + Trans(18, 16, 22, 424), + Trans(18, 17, 22, 424), + Trans(18, 18, 22, 424), + Trans(18, 19, 22, 424), + Trans(18, 20, 22, 424), + Trans(18, 21, 22, 424), + Trans(18, 22, 22, 424), + Trans(18, 23, 22, 424), + Trans(18, 24, 22, 424), + Trans(18, 25, 22, 424), + Trans(18, 26, 22, 424), + Trans(18, 30, 22, 424), + Trans(18, 31, 22, 424), + Trans(18, 32, 22, 424), + Trans(18, 33, 22, 424), + Trans(18, 39, 22, 424), + Trans(18, 41, 22, 424), + Trans(18, 42, 22, 424), + Trans(18, 43, 22, 424), + Trans(18, 44, 22, 424), + Trans(18, 45, 22, 424), + Trans(18, 46, 22, 424), + Trans(18, 47, 22, 424), + Trans(18, 51, 22, 424), + Trans(18, 93, 22, 424), + Trans(18, 102, 22, 424), + Trans(19, 5, 22, 424), + Trans(19, 6, 22, 424), + Trans(19, 7, 22, 424), + Trans(19, 8, 22, 424), + Trans(19, 9, 22, 424), + Trans(19, 10, 22, 424), + Trans(19, 11, 22, 424), + Trans(19, 18, 22, 424), + Trans(19, 24, 22, 424), + Trans(19, 25, 22, 424), + Trans(19, 26, 22, 424), + Trans(19, 27, 22, 424), + Trans(19, 30, 22, 424), + Trans(19, 36, 22, 424), + Trans(19, 38, 22, 424), + Trans(19, 39, 22, 424), + Trans(19, 41, 22, 424), + Trans(19, 43, 22, 424), + Trans(19, 48, 22, 424), + Trans(19, 49, 22, 424), + Trans(19, 50, 22, 424), + Trans(19, 53, 22, 424), + Trans(19, 57, 22, 424), + Trans(19, 60, 22, 424), + Trans(19, 61, 22, 424), + Trans(19, 64, 22, 424), + Trans(19, 65, 22, 424), + Trans(19, 66, 22, 424), + Trans(19, 69, 22, 424), + Trans(19, 70, 22, 424), + Trans(19, 71, 22, 424), + Trans(19, 73, 22, 424), + Trans(19, 76, 22, 424), + Trans(19, 77, 22, 424), + Trans(19, 80, 22, 424), + Trans(19, 81, 22, 424), + Trans(19, 83, 22, 424), + Trans(19, 84, 22, 424), + Trans(19, 86, 22, 424), + Trans(19, 88, 22, 424), + Trans(19, 99, 22, 424), + Trans(19, 100, 22, 424), + Trans(19, 104, 22, 424), + Trans(19, 106, 22, 424), + Trans(19, 109, 22, 424), + Trans(19, 110, 22, 424), + Trans(19, 111, 22, 424), + Trans(19, 112, 22, 424), + Trans(20, 5, 22, 424), + Trans(20, 111, 22, 424), + Trans(20, 112, 22, 424), + Trans(21, 5, 22, 424), + Trans(21, 6, 22, 424), + Trans(21, 7, 22, 424), + Trans(21, 8, 22, 424), + Trans(21, 9, 22, 424), + Trans(21, 10, 22, 424), + Trans(21, 11, 22, 424), + Trans(21, 15, 22, 424), + Trans(21, 18, 22, 424), + Trans(21, 24, 22, 424), + Trans(21, 25, 22, 424), + Trans(21, 26, 22, 424), + Trans(21, 27, 22, 424), + Trans(21, 38, 22, 424), + Trans(21, 39, 22, 424), + Trans(21, 41, 22, 424), + Trans(21, 53, 22, 424), + Trans(21, 70, 22, 424), + Trans(21, 76, 22, 424), + Trans(21, 83, 22, 424), + Trans(21, 86, 22, 424), + Trans(21, 88, 22, 424), + Trans(21, 111, 22, 424), + Trans(21, 112, 22, 424), + Trans(23, 5, 22, 424), + Trans(23, 12, 22, 424), + Trans(23, 14, 22, 424), + Trans(23, 16, 22, 424), + Trans(23, 17, 22, 424), + Trans(23, 18, 22, 424), + Trans(23, 19, 22, 424), + Trans(23, 20, 22, 424), + Trans(23, 21, 22, 424), + Trans(23, 22, 22, 424), + Trans(23, 23, 22, 424), + Trans(23, 24, 22, 424), + Trans(23, 25, 22, 424), + Trans(23, 26, 22, 424), + Trans(23, 30, 22, 424), + Trans(23, 31, 22, 424), + Trans(23, 32, 22, 424), + Trans(23, 33, 22, 424), + Trans(23, 39, 22, 424), + Trans(23, 42, 22, 424), + Trans(23, 43, 22, 424), + Trans(23, 44, 22, 424), + Trans(23, 45, 22, 424), + Trans(23, 46, 22, 424), + Trans(23, 47, 22, 424), + Trans(23, 51, 22, 424), + Trans(23, 93, 22, 424), + Trans(23, 102, 22, 424), ], k: 3, }, /* 20 - "ArgumentListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 418), Trans(0, 44, 2, 419)], + transitions: &[Trans(0, 31, 1, 425), Trans(0, 45, 2, 426)], k: 1, }, /* 21 - "Array" */ LookaheadDFA { - prod0: 471, + prod0: 478, transitions: &[], k: 0, }, /* 22 - "ArrayList" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 472), Trans(0, 43, 2, 473)], + transitions: &[Trans(0, 31, 1, 479), Trans(0, 44, 2, 480)], k: 1, }, /* 23 - "ArrayLiteralItem" */ LookaheadDFA { - prod0: 434, + prod0: 441, transitions: &[], k: 0, }, @@ -1720,29 +1869,29 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 1, 435), - Trans(0, 7, 1, 435), - Trans(0, 8, 1, 435), - Trans(0, 9, 1, 435), - Trans(0, 10, 1, 435), - Trans(0, 11, 1, 435), - Trans(0, 18, 1, 435), - Trans(0, 24, 1, 435), - Trans(0, 25, 1, 435), - Trans(0, 26, 1, 435), - Trans(0, 27, 1, 435), - Trans(0, 37, 1, 435), - Trans(0, 38, 1, 435), - Trans(0, 40, 1, 435), - Trans(0, 52, 1, 435), - Trans(0, 56, 2, 436), - Trans(0, 69, 1, 435), - Trans(0, 75, 1, 435), - Trans(0, 82, 1, 435), - Trans(0, 85, 1, 435), - Trans(0, 87, 1, 435), - Trans(0, 110, 1, 435), - Trans(0, 111, 1, 435), + Trans(0, 6, 1, 442), + Trans(0, 7, 1, 442), + Trans(0, 8, 1, 442), + Trans(0, 9, 1, 442), + Trans(0, 10, 1, 442), + Trans(0, 11, 1, 442), + Trans(0, 18, 1, 442), + Trans(0, 24, 1, 442), + Trans(0, 25, 1, 442), + Trans(0, 26, 1, 442), + Trans(0, 27, 1, 442), + Trans(0, 38, 1, 442), + Trans(0, 39, 1, 442), + Trans(0, 41, 1, 442), + Trans(0, 53, 1, 442), + Trans(0, 57, 2, 443), + Trans(0, 70, 1, 442), + Trans(0, 76, 1, 442), + Trans(0, 83, 1, 442), + Trans(0, 86, 1, 442), + Trans(0, 88, 1, 442), + Trans(0, 111, 1, 442), + Trans(0, 112, 1, 442), ], k: 1, }, @@ -1750,15 +1899,15 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 2, 438), - Trans(0, 42, 2, 438), - Trans(0, 92, 1, 437), + Trans(0, 31, 2, 445), + Trans(0, 43, 2, 445), + Trans(0, 93, 1, 444), ], k: 1, }, /* 26 - "ArrayLiteralList" */ LookaheadDFA { - prod0: 429, + prod0: 436, transitions: &[], k: 0, }, @@ -1766,9 +1915,9 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 9, -1), - Trans(1, 5, 8, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 10, -1), + Trans(1, 5, 9, -1), Trans(1, 6, 2, -1), Trans(1, 7, 2, -1), Trans(1, 8, 2, -1), @@ -1780,548 +1929,570 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(1, 25, 4, -1), Trans(1, 26, 4, -1), Trans(1, 27, 4, -1), - Trans(1, 37, 5, -1), - Trans(1, 38, 4, -1), - Trans(1, 40, 4, -1), - Trans(1, 42, 23, -1), - Trans(1, 52, 4, -1), - Trans(1, 56, 6, -1), - Trans(1, 69, 4, -1), - Trans(1, 75, 4, -1), - Trans(1, 82, 2, -1), - Trans(1, 85, 2, -1), - Trans(1, 87, 4, -1), - Trans(1, 110, 7, -1), + Trans(1, 38, 5, -1), + Trans(1, 39, 4, -1), + Trans(1, 41, 4, -1), + Trans(1, 43, 24, -1), + Trans(1, 53, 4, -1), + Trans(1, 57, 6, -1), + Trans(1, 70, 4, -1), + Trans(1, 76, 4, -1), + Trans(1, 83, 2, -1), + Trans(1, 86, 2, -1), + Trans(1, 88, 4, -1), Trans(1, 111, 7, -1), - Trans(2, 5, 3, 430), - Trans(2, 16, 3, 430), - Trans(2, 17, 3, 430), - Trans(2, 18, 3, 430), - Trans(2, 19, 3, 430), - Trans(2, 20, 3, 430), - Trans(2, 21, 3, 430), - Trans(2, 22, 3, 430), - Trans(2, 23, 3, 430), - Trans(2, 24, 3, 430), - Trans(2, 25, 3, 430), - Trans(2, 26, 3, 430), - Trans(2, 30, 3, 430), - Trans(2, 42, 3, 430), - Trans(2, 46, 3, 430), - Trans(2, 50, 3, 430), - Trans(2, 92, 3, 430), - Trans(4, 5, 3, 430), - Trans(4, 6, 3, 430), - Trans(4, 7, 3, 430), - Trans(4, 8, 3, 430), - Trans(4, 9, 3, 430), - Trans(4, 10, 3, 430), - Trans(4, 11, 3, 430), - Trans(4, 18, 3, 430), - Trans(4, 24, 3, 430), - Trans(4, 25, 3, 430), - Trans(4, 26, 3, 430), - Trans(4, 27, 3, 430), - Trans(4, 37, 3, 430), - Trans(4, 38, 3, 430), - Trans(4, 40, 3, 430), - Trans(4, 52, 3, 430), - Trans(4, 69, 3, 430), - Trans(4, 75, 3, 430), - Trans(4, 82, 3, 430), - Trans(4, 85, 3, 430), - Trans(4, 87, 3, 430), - Trans(4, 110, 3, 430), - Trans(4, 111, 3, 430), - Trans(5, 5, 3, 430), - Trans(5, 6, 3, 430), - Trans(5, 7, 3, 430), - Trans(5, 8, 3, 430), - Trans(5, 9, 3, 430), - Trans(5, 10, 3, 430), - Trans(5, 11, 3, 430), - Trans(5, 18, 3, 430), - Trans(5, 24, 3, 430), - Trans(5, 25, 3, 430), - Trans(5, 26, 3, 430), - Trans(5, 27, 3, 430), - Trans(5, 37, 3, 430), - Trans(5, 38, 3, 430), - Trans(5, 40, 3, 430), - Trans(5, 52, 3, 430), - Trans(5, 56, 3, 430), - Trans(5, 69, 3, 430), - Trans(5, 75, 3, 430), - Trans(5, 82, 3, 430), - Trans(5, 85, 3, 430), - Trans(5, 87, 3, 430), - Trans(5, 110, 3, 430), - Trans(5, 111, 3, 430), - Trans(6, 5, 3, 430), - Trans(6, 29, 3, 430), - Trans(7, 5, 3, 430), - Trans(7, 16, 3, 430), - Trans(7, 17, 3, 430), - Trans(7, 18, 3, 430), - Trans(7, 19, 3, 430), - Trans(7, 20, 3, 430), - Trans(7, 21, 3, 430), - Trans(7, 22, 3, 430), - Trans(7, 23, 3, 430), - Trans(7, 24, 3, 430), - Trans(7, 25, 3, 430), - Trans(7, 26, 3, 430), - Trans(7, 28, 3, 430), - Trans(7, 30, 3, 430), - Trans(7, 33, 3, 430), - Trans(7, 39, 3, 430), - Trans(7, 40, 3, 430), - Trans(7, 42, 3, 430), - Trans(7, 46, 3, 430), - Trans(7, 50, 3, 430), - Trans(7, 92, 3, 430), - Trans(8, 6, 3, 430), - Trans(8, 7, 3, 430), - Trans(8, 8, 3, 430), - Trans(8, 9, 3, 430), - Trans(8, 10, 3, 430), - Trans(8, 11, 3, 430), - Trans(8, 18, 3, 430), - Trans(8, 24, 3, 430), - Trans(8, 25, 3, 430), - Trans(8, 26, 3, 430), - Trans(8, 27, 3, 430), - Trans(8, 37, 3, 430), - Trans(8, 38, 3, 430), - Trans(8, 40, 3, 430), - Trans(8, 42, 22, 431), - Trans(8, 52, 3, 430), - Trans(8, 56, 3, 430), - Trans(8, 69, 3, 430), - Trans(8, 75, 3, 430), - Trans(8, 82, 3, 430), - Trans(8, 85, 3, 430), - Trans(8, 87, 3, 430), - Trans(8, 110, 3, 430), - Trans(8, 111, 3, 430), - Trans(9, 5, 10, -1), - Trans(9, 12, 11, -1), - Trans(9, 14, 11, -1), - Trans(9, 16, 11, -1), - Trans(9, 17, 11, -1), - Trans(9, 18, 11, -1), - Trans(9, 19, 11, -1), - Trans(9, 20, 11, -1), - Trans(9, 21, 11, -1), - Trans(9, 22, 11, -1), - Trans(9, 23, 11, -1), - Trans(9, 24, 11, -1), - Trans(9, 25, 11, -1), - Trans(9, 26, 11, -1), - Trans(9, 29, 12, -1), - Trans(9, 30, 13, -1), - Trans(9, 31, 11, -1), - Trans(9, 32, 11, -1), - Trans(9, 38, 14, -1), - Trans(9, 41, 15, -1), - Trans(9, 42, 16, -1), - Trans(9, 43, 17, -1), - Trans(9, 44, 18, -1), - Trans(9, 45, 19, -1), - Trans(9, 46, 11, -1), - Trans(9, 50, 20, -1), - Trans(9, 92, 11, -1), - Trans(9, 101, 21, -1), - Trans(10, 12, 22, 431), - Trans(10, 14, 22, 431), - Trans(10, 16, 22, 431), - Trans(10, 17, 22, 431), - Trans(10, 18, 22, 431), - Trans(10, 19, 22, 431), - Trans(10, 20, 22, 431), - Trans(10, 21, 22, 431), - Trans(10, 22, 22, 431), - Trans(10, 23, 22, 431), - Trans(10, 24, 22, 431), - Trans(10, 25, 22, 431), - Trans(10, 26, 22, 431), - Trans(10, 29, 22, 431), - Trans(10, 30, 22, 431), - Trans(10, 31, 22, 431), - Trans(10, 32, 22, 431), - Trans(10, 38, 22, 431), - Trans(10, 41, 22, 431), - Trans(10, 42, 22, 431), - Trans(10, 43, 22, 431), - Trans(10, 44, 22, 431), - Trans(10, 45, 22, 431), - Trans(10, 46, 22, 431), - Trans(10, 50, 22, 431), - Trans(10, 92, 22, 431), - Trans(10, 101, 22, 431), - Trans(11, 5, 22, 431), - Trans(11, 6, 22, 431), - Trans(11, 7, 22, 431), - Trans(11, 8, 22, 431), - Trans(11, 9, 22, 431), - Trans(11, 10, 22, 431), - Trans(11, 11, 22, 431), - Trans(11, 18, 22, 431), - Trans(11, 24, 22, 431), - Trans(11, 25, 22, 431), - Trans(11, 26, 22, 431), - Trans(11, 27, 22, 431), - Trans(11, 37, 22, 431), - Trans(11, 38, 22, 431), - Trans(11, 40, 22, 431), - Trans(11, 52, 22, 431), - Trans(11, 69, 22, 431), - Trans(11, 75, 22, 431), - Trans(11, 82, 22, 431), - Trans(11, 85, 22, 431), - Trans(11, 87, 22, 431), - Trans(11, 110, 22, 431), - Trans(11, 111, 22, 431), - Trans(12, 5, 22, 431), - Trans(12, 6, 22, 431), - Trans(12, 7, 22, 431), - Trans(12, 8, 22, 431), - Trans(12, 9, 22, 431), - Trans(12, 10, 22, 431), - Trans(12, 11, 22, 431), - Trans(12, 18, 22, 431), - Trans(12, 24, 22, 431), - Trans(12, 25, 22, 431), - Trans(12, 26, 22, 431), - Trans(12, 27, 22, 431), - Trans(12, 37, 22, 431), - Trans(12, 38, 22, 431), - Trans(12, 40, 22, 431), - Trans(12, 52, 22, 431), - Trans(12, 64, 22, 431), - Trans(12, 68, 22, 431), - Trans(12, 69, 22, 431), - Trans(12, 75, 22, 431), - Trans(12, 79, 22, 431), - Trans(12, 82, 22, 431), - Trans(12, 85, 22, 431), - Trans(12, 87, 22, 431), - Trans(12, 98, 22, 431), - Trans(12, 99, 22, 431), - Trans(12, 110, 22, 431), - Trans(12, 111, 22, 431), - Trans(13, 5, 22, 431), - Trans(13, 6, 22, 431), - Trans(13, 7, 22, 431), - Trans(13, 8, 22, 431), - Trans(13, 9, 22, 431), - Trans(13, 10, 22, 431), - Trans(13, 11, 22, 431), - Trans(13, 18, 22, 431), - Trans(13, 24, 22, 431), - Trans(13, 25, 22, 431), - Trans(13, 26, 22, 431), - Trans(13, 27, 22, 431), - Trans(13, 35, 22, 431), - Trans(13, 37, 22, 431), - Trans(13, 38, 22, 431), - Trans(13, 40, 22, 431), - Trans(13, 42, 22, 431), - Trans(13, 44, 22, 431), - Trans(13, 52, 22, 431), - Trans(13, 56, 22, 431), - Trans(13, 69, 22, 431), - Trans(13, 75, 22, 431), - Trans(13, 80, 22, 431), - Trans(13, 82, 22, 431), - Trans(13, 85, 22, 431), - Trans(13, 87, 22, 431), - Trans(13, 89, 22, 431), - Trans(13, 110, 22, 431), - Trans(13, 111, 22, 431), - Trans(14, 5, 22, 431), - Trans(14, 6, 22, 431), - Trans(14, 7, 22, 431), - Trans(14, 8, 22, 431), - Trans(14, 9, 22, 431), - Trans(14, 10, 22, 431), - Trans(14, 11, 22, 431), - Trans(14, 18, 22, 431), - Trans(14, 24, 22, 431), - Trans(14, 25, 22, 431), - Trans(14, 26, 22, 431), - Trans(14, 27, 22, 431), - Trans(14, 29, 22, 431), - Trans(14, 35, 22, 431), - Trans(14, 37, 22, 431), - Trans(14, 38, 22, 431), - Trans(14, 40, 22, 431), - Trans(14, 42, 22, 431), - Trans(14, 47, 22, 431), - Trans(14, 48, 22, 431), - Trans(14, 49, 22, 431), - Trans(14, 52, 22, 431), - Trans(14, 56, 22, 431), - Trans(14, 59, 22, 431), - Trans(14, 63, 22, 431), - Trans(14, 64, 22, 431), - Trans(14, 65, 22, 431), - Trans(14, 68, 22, 431), - Trans(14, 69, 22, 431), - Trans(14, 70, 22, 431), - Trans(14, 72, 22, 431), - Trans(14, 75, 22, 431), - Trans(14, 76, 22, 431), - Trans(14, 79, 22, 431), - Trans(14, 80, 22, 431), - Trans(14, 82, 22, 431), - Trans(14, 83, 22, 431), - Trans(14, 85, 22, 431), - Trans(14, 87, 22, 431), - Trans(14, 98, 22, 431), - Trans(14, 99, 22, 431), - Trans(14, 103, 22, 431), - Trans(14, 105, 22, 431), - Trans(14, 108, 22, 431), - Trans(14, 109, 22, 431), - Trans(14, 110, 22, 431), - Trans(14, 111, 22, 431), - Trans(15, 5, 22, 431), - Trans(15, 30, 22, 431), - Trans(15, 34, 22, 431), - Trans(15, 38, 22, 431), - Trans(15, 39, 22, 431), - Trans(15, 42, 22, 431), - Trans(15, 44, 22, 431), - Trans(15, 45, 22, 431), - Trans(15, 78, 22, 431), - Trans(16, 5, 22, 431), - Trans(16, 12, 22, 431), - Trans(16, 14, 22, 431), - Trans(16, 16, 22, 431), - Trans(16, 17, 22, 431), - Trans(16, 18, 22, 431), - Trans(16, 19, 22, 431), - Trans(16, 20, 22, 431), - Trans(16, 21, 22, 431), - Trans(16, 22, 22, 431), - Trans(16, 23, 22, 431), - Trans(16, 24, 22, 431), - Trans(16, 25, 22, 431), - Trans(16, 26, 22, 431), - Trans(16, 29, 22, 431), - Trans(16, 30, 22, 431), - Trans(16, 31, 22, 431), - Trans(16, 32, 22, 431), - Trans(16, 35, 22, 431), - Trans(16, 38, 22, 431), - Trans(16, 41, 22, 431), - Trans(16, 42, 22, 431), - Trans(16, 43, 22, 431), - Trans(16, 44, 22, 431), - Trans(16, 45, 22, 431), - Trans(16, 46, 22, 431), - Trans(16, 47, 22, 431), - Trans(16, 48, 22, 431), - Trans(16, 49, 22, 431), - Trans(16, 50, 22, 431), - Trans(16, 57, 22, 431), - Trans(16, 59, 22, 431), - Trans(16, 60, 22, 431), - Trans(16, 63, 22, 431), - Trans(16, 64, 22, 431), - Trans(16, 65, 22, 431), - Trans(16, 69, 22, 431), - Trans(16, 70, 22, 431), - Trans(16, 72, 22, 431), - Trans(16, 76, 22, 431), - Trans(16, 79, 22, 431), - Trans(16, 80, 22, 431), - Trans(16, 83, 22, 431), - Trans(16, 92, 22, 431), - Trans(16, 101, 22, 431), - Trans(16, 103, 22, 431), - Trans(16, 105, 22, 431), - Trans(16, 108, 22, 431), - Trans(16, 109, 22, 431), - Trans(17, 5, 22, 431), - Trans(17, 12, 22, 431), - Trans(17, 14, 22, 431), - Trans(17, 15, 22, 431), - Trans(17, 16, 22, 431), - Trans(17, 17, 22, 431), - Trans(17, 18, 22, 431), - Trans(17, 19, 22, 431), - Trans(17, 20, 22, 431), - Trans(17, 21, 22, 431), - Trans(17, 22, 22, 431), - Trans(17, 23, 22, 431), - Trans(17, 24, 22, 431), - Trans(17, 25, 22, 431), - Trans(17, 26, 22, 431), - Trans(17, 29, 22, 431), - Trans(17, 30, 22, 431), - Trans(17, 31, 22, 431), - Trans(17, 32, 22, 431), - Trans(17, 33, 22, 431), - Trans(17, 34, 22, 431), - Trans(17, 35, 22, 431), - Trans(17, 38, 22, 431), - Trans(17, 39, 22, 431), - Trans(17, 40, 22, 431), - Trans(17, 41, 22, 431), - Trans(17, 42, 22, 431), - Trans(17, 43, 22, 431), - Trans(17, 44, 22, 431), - Trans(17, 45, 22, 431), - Trans(17, 46, 22, 431), - Trans(17, 50, 22, 431), - Trans(17, 92, 22, 431), - Trans(17, 101, 22, 431), - Trans(18, 5, 22, 431), - Trans(18, 12, 22, 431), - Trans(18, 14, 22, 431), - Trans(18, 16, 22, 431), - Trans(18, 17, 22, 431), - Trans(18, 18, 22, 431), - Trans(18, 19, 22, 431), - Trans(18, 20, 22, 431), - Trans(18, 21, 22, 431), - Trans(18, 22, 22, 431), - Trans(18, 23, 22, 431), - Trans(18, 24, 22, 431), - Trans(18, 25, 22, 431), - Trans(18, 26, 22, 431), - Trans(18, 29, 22, 431), - Trans(18, 30, 22, 431), - Trans(18, 31, 22, 431), - Trans(18, 32, 22, 431), - Trans(18, 38, 22, 431), - Trans(18, 40, 22, 431), - Trans(18, 41, 22, 431), - Trans(18, 42, 22, 431), - Trans(18, 43, 22, 431), - Trans(18, 44, 22, 431), - Trans(18, 45, 22, 431), - Trans(18, 46, 22, 431), - Trans(18, 50, 22, 431), - Trans(18, 92, 22, 431), - Trans(18, 101, 22, 431), - Trans(19, 5, 22, 431), - Trans(19, 6, 22, 431), - Trans(19, 7, 22, 431), - Trans(19, 8, 22, 431), - Trans(19, 9, 22, 431), - Trans(19, 10, 22, 431), - Trans(19, 11, 22, 431), - Trans(19, 18, 22, 431), - Trans(19, 24, 22, 431), - Trans(19, 25, 22, 431), - Trans(19, 26, 22, 431), - Trans(19, 27, 22, 431), - Trans(19, 29, 22, 431), - Trans(19, 35, 22, 431), - Trans(19, 37, 22, 431), - Trans(19, 38, 22, 431), - Trans(19, 40, 22, 431), - Trans(19, 42, 22, 431), - Trans(19, 47, 22, 431), - Trans(19, 48, 22, 431), - Trans(19, 49, 22, 431), - Trans(19, 52, 22, 431), - Trans(19, 56, 22, 431), - Trans(19, 59, 22, 431), - Trans(19, 60, 22, 431), - Trans(19, 63, 22, 431), - Trans(19, 64, 22, 431), - Trans(19, 65, 22, 431), - Trans(19, 68, 22, 431), - Trans(19, 69, 22, 431), - Trans(19, 70, 22, 431), - Trans(19, 72, 22, 431), - Trans(19, 75, 22, 431), - Trans(19, 76, 22, 431), - Trans(19, 79, 22, 431), - Trans(19, 80, 22, 431), - Trans(19, 82, 22, 431), - Trans(19, 83, 22, 431), - Trans(19, 85, 22, 431), - Trans(19, 87, 22, 431), - Trans(19, 98, 22, 431), - Trans(19, 99, 22, 431), - Trans(19, 103, 22, 431), - Trans(19, 105, 22, 431), - Trans(19, 108, 22, 431), - Trans(19, 109, 22, 431), - Trans(19, 110, 22, 431), - Trans(19, 111, 22, 431), - Trans(20, 5, 22, 431), - Trans(20, 110, 22, 431), - Trans(20, 111, 22, 431), - Trans(21, 5, 22, 431), - Trans(21, 6, 22, 431), - Trans(21, 7, 22, 431), - Trans(21, 8, 22, 431), - Trans(21, 9, 22, 431), - Trans(21, 10, 22, 431), - Trans(21, 11, 22, 431), - Trans(21, 15, 22, 431), - Trans(21, 18, 22, 431), - Trans(21, 24, 22, 431), - Trans(21, 25, 22, 431), - Trans(21, 26, 22, 431), - Trans(21, 27, 22, 431), - Trans(21, 37, 22, 431), - Trans(21, 38, 22, 431), - Trans(21, 40, 22, 431), - Trans(21, 52, 22, 431), - Trans(21, 69, 22, 431), - Trans(21, 75, 22, 431), - Trans(21, 82, 22, 431), - Trans(21, 85, 22, 431), - Trans(21, 87, 22, 431), - Trans(21, 110, 22, 431), - Trans(21, 111, 22, 431), - Trans(23, 5, 22, 431), - Trans(23, 12, 22, 431), - Trans(23, 14, 22, 431), - Trans(23, 16, 22, 431), - Trans(23, 17, 22, 431), - Trans(23, 18, 22, 431), - Trans(23, 19, 22, 431), - Trans(23, 20, 22, 431), - Trans(23, 21, 22, 431), - Trans(23, 22, 22, 431), - Trans(23, 23, 22, 431), - Trans(23, 24, 22, 431), - Trans(23, 25, 22, 431), - Trans(23, 26, 22, 431), - Trans(23, 29, 22, 431), - Trans(23, 30, 22, 431), - Trans(23, 31, 22, 431), - Trans(23, 32, 22, 431), - Trans(23, 38, 22, 431), - Trans(23, 41, 22, 431), - Trans(23, 42, 22, 431), - Trans(23, 43, 22, 431), - Trans(23, 44, 22, 431), - Trans(23, 45, 22, 431), - Trans(23, 46, 22, 431), - Trans(23, 50, 22, 431), - Trans(23, 92, 22, 431), - Trans(23, 101, 22, 431), + Trans(1, 112, 8, -1), + Trans(2, 5, 3, 437), + Trans(2, 16, 3, 437), + Trans(2, 17, 3, 437), + Trans(2, 18, 3, 437), + Trans(2, 19, 3, 437), + Trans(2, 20, 3, 437), + Trans(2, 21, 3, 437), + Trans(2, 22, 3, 437), + Trans(2, 23, 3, 437), + Trans(2, 24, 3, 437), + Trans(2, 25, 3, 437), + Trans(2, 26, 3, 437), + Trans(2, 31, 3, 437), + Trans(2, 43, 3, 437), + Trans(2, 47, 3, 437), + Trans(2, 51, 3, 437), + Trans(2, 93, 3, 437), + Trans(4, 5, 3, 437), + Trans(4, 6, 3, 437), + Trans(4, 7, 3, 437), + Trans(4, 8, 3, 437), + Trans(4, 9, 3, 437), + Trans(4, 10, 3, 437), + Trans(4, 11, 3, 437), + Trans(4, 18, 3, 437), + Trans(4, 24, 3, 437), + Trans(4, 25, 3, 437), + Trans(4, 26, 3, 437), + Trans(4, 27, 3, 437), + Trans(4, 38, 3, 437), + Trans(4, 39, 3, 437), + Trans(4, 41, 3, 437), + Trans(4, 53, 3, 437), + Trans(4, 70, 3, 437), + Trans(4, 76, 3, 437), + Trans(4, 83, 3, 437), + Trans(4, 86, 3, 437), + Trans(4, 88, 3, 437), + Trans(4, 111, 3, 437), + Trans(4, 112, 3, 437), + Trans(5, 5, 3, 437), + Trans(5, 6, 3, 437), + Trans(5, 7, 3, 437), + Trans(5, 8, 3, 437), + Trans(5, 9, 3, 437), + Trans(5, 10, 3, 437), + Trans(5, 11, 3, 437), + Trans(5, 18, 3, 437), + Trans(5, 24, 3, 437), + Trans(5, 25, 3, 437), + Trans(5, 26, 3, 437), + Trans(5, 27, 3, 437), + Trans(5, 38, 3, 437), + Trans(5, 39, 3, 437), + Trans(5, 41, 3, 437), + Trans(5, 53, 3, 437), + Trans(5, 57, 3, 437), + Trans(5, 70, 3, 437), + Trans(5, 76, 3, 437), + Trans(5, 83, 3, 437), + Trans(5, 86, 3, 437), + Trans(5, 88, 3, 437), + Trans(5, 111, 3, 437), + Trans(5, 112, 3, 437), + Trans(6, 5, 3, 437), + Trans(6, 30, 3, 437), + Trans(7, 5, 3, 437), + Trans(7, 16, 3, 437), + Trans(7, 17, 3, 437), + Trans(7, 18, 3, 437), + Trans(7, 19, 3, 437), + Trans(7, 20, 3, 437), + Trans(7, 21, 3, 437), + Trans(7, 22, 3, 437), + Trans(7, 23, 3, 437), + Trans(7, 24, 3, 437), + Trans(7, 25, 3, 437), + Trans(7, 26, 3, 437), + Trans(7, 29, 3, 437), + Trans(7, 31, 3, 437), + Trans(7, 34, 3, 437), + Trans(7, 40, 3, 437), + Trans(7, 41, 3, 437), + Trans(7, 43, 3, 437), + Trans(7, 47, 3, 437), + Trans(7, 51, 3, 437), + Trans(7, 93, 3, 437), + Trans(8, 5, 3, 437), + Trans(8, 16, 3, 437), + Trans(8, 17, 3, 437), + Trans(8, 18, 3, 437), + Trans(8, 19, 3, 437), + Trans(8, 20, 3, 437), + Trans(8, 21, 3, 437), + Trans(8, 22, 3, 437), + Trans(8, 23, 3, 437), + Trans(8, 24, 3, 437), + Trans(8, 25, 3, 437), + Trans(8, 26, 3, 437), + Trans(8, 28, 3, 437), + Trans(8, 29, 3, 437), + Trans(8, 31, 3, 437), + Trans(8, 34, 3, 437), + Trans(8, 40, 3, 437), + Trans(8, 41, 3, 437), + Trans(8, 43, 3, 437), + Trans(8, 47, 3, 437), + Trans(8, 51, 3, 437), + Trans(8, 93, 3, 437), + Trans(9, 6, 3, 437), + Trans(9, 7, 3, 437), + Trans(9, 8, 3, 437), + Trans(9, 9, 3, 437), + Trans(9, 10, 3, 437), + Trans(9, 11, 3, 437), + Trans(9, 18, 3, 437), + Trans(9, 24, 3, 437), + Trans(9, 25, 3, 437), + Trans(9, 26, 3, 437), + Trans(9, 27, 3, 437), + Trans(9, 38, 3, 437), + Trans(9, 39, 3, 437), + Trans(9, 41, 3, 437), + Trans(9, 43, 23, 438), + Trans(9, 53, 3, 437), + Trans(9, 57, 3, 437), + Trans(9, 70, 3, 437), + Trans(9, 76, 3, 437), + Trans(9, 83, 3, 437), + Trans(9, 86, 3, 437), + Trans(9, 88, 3, 437), + Trans(9, 111, 3, 437), + Trans(9, 112, 3, 437), + Trans(10, 5, 11, -1), + Trans(10, 12, 12, -1), + Trans(10, 14, 12, -1), + Trans(10, 16, 12, -1), + Trans(10, 17, 12, -1), + Trans(10, 18, 12, -1), + Trans(10, 19, 12, -1), + Trans(10, 20, 12, -1), + Trans(10, 21, 12, -1), + Trans(10, 22, 12, -1), + Trans(10, 23, 12, -1), + Trans(10, 24, 12, -1), + Trans(10, 25, 12, -1), + Trans(10, 26, 12, -1), + Trans(10, 30, 13, -1), + Trans(10, 31, 14, -1), + Trans(10, 32, 12, -1), + Trans(10, 33, 12, -1), + Trans(10, 39, 15, -1), + Trans(10, 42, 16, -1), + Trans(10, 43, 17, -1), + Trans(10, 44, 18, -1), + Trans(10, 45, 19, -1), + Trans(10, 46, 20, -1), + Trans(10, 47, 12, -1), + Trans(10, 51, 21, -1), + Trans(10, 93, 12, -1), + Trans(10, 102, 22, -1), + Trans(11, 12, 23, 438), + Trans(11, 14, 23, 438), + Trans(11, 16, 23, 438), + Trans(11, 17, 23, 438), + Trans(11, 18, 23, 438), + Trans(11, 19, 23, 438), + Trans(11, 20, 23, 438), + Trans(11, 21, 23, 438), + Trans(11, 22, 23, 438), + Trans(11, 23, 23, 438), + Trans(11, 24, 23, 438), + Trans(11, 25, 23, 438), + Trans(11, 26, 23, 438), + Trans(11, 30, 23, 438), + Trans(11, 31, 23, 438), + Trans(11, 32, 23, 438), + Trans(11, 33, 23, 438), + Trans(11, 39, 23, 438), + Trans(11, 42, 23, 438), + Trans(11, 43, 23, 438), + Trans(11, 44, 23, 438), + Trans(11, 45, 23, 438), + Trans(11, 46, 23, 438), + Trans(11, 47, 23, 438), + Trans(11, 51, 23, 438), + Trans(11, 93, 23, 438), + Trans(11, 102, 23, 438), + Trans(12, 5, 23, 438), + Trans(12, 6, 23, 438), + Trans(12, 7, 23, 438), + Trans(12, 8, 23, 438), + Trans(12, 9, 23, 438), + Trans(12, 10, 23, 438), + Trans(12, 11, 23, 438), + Trans(12, 18, 23, 438), + Trans(12, 24, 23, 438), + Trans(12, 25, 23, 438), + Trans(12, 26, 23, 438), + Trans(12, 27, 23, 438), + Trans(12, 38, 23, 438), + Trans(12, 39, 23, 438), + Trans(12, 41, 23, 438), + Trans(12, 53, 23, 438), + Trans(12, 70, 23, 438), + Trans(12, 76, 23, 438), + Trans(12, 83, 23, 438), + Trans(12, 86, 23, 438), + Trans(12, 88, 23, 438), + Trans(12, 111, 23, 438), + Trans(12, 112, 23, 438), + Trans(13, 5, 23, 438), + Trans(13, 6, 23, 438), + Trans(13, 7, 23, 438), + Trans(13, 8, 23, 438), + Trans(13, 9, 23, 438), + Trans(13, 10, 23, 438), + Trans(13, 11, 23, 438), + Trans(13, 18, 23, 438), + Trans(13, 24, 23, 438), + Trans(13, 25, 23, 438), + Trans(13, 26, 23, 438), + Trans(13, 27, 23, 438), + Trans(13, 38, 23, 438), + Trans(13, 39, 23, 438), + Trans(13, 41, 23, 438), + Trans(13, 53, 23, 438), + Trans(13, 65, 23, 438), + Trans(13, 69, 23, 438), + Trans(13, 70, 23, 438), + Trans(13, 76, 23, 438), + Trans(13, 80, 23, 438), + Trans(13, 83, 23, 438), + Trans(13, 86, 23, 438), + Trans(13, 88, 23, 438), + Trans(13, 99, 23, 438), + Trans(13, 100, 23, 438), + Trans(13, 111, 23, 438), + Trans(13, 112, 23, 438), + Trans(14, 5, 23, 438), + Trans(14, 6, 23, 438), + Trans(14, 7, 23, 438), + Trans(14, 8, 23, 438), + Trans(14, 9, 23, 438), + Trans(14, 10, 23, 438), + Trans(14, 11, 23, 438), + Trans(14, 18, 23, 438), + Trans(14, 24, 23, 438), + Trans(14, 25, 23, 438), + Trans(14, 26, 23, 438), + Trans(14, 27, 23, 438), + Trans(14, 36, 23, 438), + Trans(14, 38, 23, 438), + Trans(14, 39, 23, 438), + Trans(14, 41, 23, 438), + Trans(14, 43, 23, 438), + Trans(14, 45, 23, 438), + Trans(14, 53, 23, 438), + Trans(14, 57, 23, 438), + Trans(14, 70, 23, 438), + Trans(14, 76, 23, 438), + Trans(14, 81, 23, 438), + Trans(14, 83, 23, 438), + Trans(14, 86, 23, 438), + Trans(14, 88, 23, 438), + Trans(14, 90, 23, 438), + Trans(14, 111, 23, 438), + Trans(14, 112, 23, 438), + Trans(15, 5, 23, 438), + Trans(15, 6, 23, 438), + Trans(15, 7, 23, 438), + Trans(15, 8, 23, 438), + Trans(15, 9, 23, 438), + Trans(15, 10, 23, 438), + Trans(15, 11, 23, 438), + Trans(15, 18, 23, 438), + Trans(15, 24, 23, 438), + Trans(15, 25, 23, 438), + Trans(15, 26, 23, 438), + Trans(15, 27, 23, 438), + Trans(15, 30, 23, 438), + Trans(15, 36, 23, 438), + Trans(15, 38, 23, 438), + Trans(15, 39, 23, 438), + Trans(15, 41, 23, 438), + Trans(15, 43, 23, 438), + Trans(15, 48, 23, 438), + Trans(15, 49, 23, 438), + Trans(15, 50, 23, 438), + Trans(15, 53, 23, 438), + Trans(15, 57, 23, 438), + Trans(15, 60, 23, 438), + Trans(15, 64, 23, 438), + Trans(15, 65, 23, 438), + Trans(15, 66, 23, 438), + Trans(15, 69, 23, 438), + Trans(15, 70, 23, 438), + Trans(15, 71, 23, 438), + Trans(15, 73, 23, 438), + Trans(15, 76, 23, 438), + Trans(15, 77, 23, 438), + Trans(15, 80, 23, 438), + Trans(15, 81, 23, 438), + Trans(15, 83, 23, 438), + Trans(15, 84, 23, 438), + Trans(15, 86, 23, 438), + Trans(15, 88, 23, 438), + Trans(15, 99, 23, 438), + Trans(15, 100, 23, 438), + Trans(15, 104, 23, 438), + Trans(15, 106, 23, 438), + Trans(15, 109, 23, 438), + Trans(15, 110, 23, 438), + Trans(15, 111, 23, 438), + Trans(15, 112, 23, 438), + Trans(16, 5, 23, 438), + Trans(16, 31, 23, 438), + Trans(16, 35, 23, 438), + Trans(16, 39, 23, 438), + Trans(16, 40, 23, 438), + Trans(16, 43, 23, 438), + Trans(16, 45, 23, 438), + Trans(16, 46, 23, 438), + Trans(16, 79, 23, 438), + Trans(17, 5, 23, 438), + Trans(17, 12, 23, 438), + Trans(17, 14, 23, 438), + Trans(17, 16, 23, 438), + Trans(17, 17, 23, 438), + Trans(17, 18, 23, 438), + Trans(17, 19, 23, 438), + Trans(17, 20, 23, 438), + Trans(17, 21, 23, 438), + Trans(17, 22, 23, 438), + Trans(17, 23, 23, 438), + Trans(17, 24, 23, 438), + Trans(17, 25, 23, 438), + Trans(17, 26, 23, 438), + Trans(17, 30, 23, 438), + Trans(17, 31, 23, 438), + Trans(17, 32, 23, 438), + Trans(17, 33, 23, 438), + Trans(17, 36, 23, 438), + Trans(17, 39, 23, 438), + Trans(17, 42, 23, 438), + Trans(17, 43, 23, 438), + Trans(17, 44, 23, 438), + Trans(17, 45, 23, 438), + Trans(17, 46, 23, 438), + Trans(17, 47, 23, 438), + Trans(17, 48, 23, 438), + Trans(17, 49, 23, 438), + Trans(17, 50, 23, 438), + Trans(17, 51, 23, 438), + Trans(17, 58, 23, 438), + Trans(17, 60, 23, 438), + Trans(17, 61, 23, 438), + Trans(17, 64, 23, 438), + Trans(17, 65, 23, 438), + Trans(17, 66, 23, 438), + Trans(17, 70, 23, 438), + Trans(17, 71, 23, 438), + Trans(17, 73, 23, 438), + Trans(17, 77, 23, 438), + Trans(17, 80, 23, 438), + Trans(17, 81, 23, 438), + Trans(17, 84, 23, 438), + Trans(17, 93, 23, 438), + Trans(17, 102, 23, 438), + Trans(17, 104, 23, 438), + Trans(17, 106, 23, 438), + Trans(17, 109, 23, 438), + Trans(17, 110, 23, 438), + Trans(18, 5, 23, 438), + Trans(18, 12, 23, 438), + Trans(18, 14, 23, 438), + Trans(18, 15, 23, 438), + Trans(18, 16, 23, 438), + Trans(18, 17, 23, 438), + Trans(18, 18, 23, 438), + Trans(18, 19, 23, 438), + Trans(18, 20, 23, 438), + Trans(18, 21, 23, 438), + Trans(18, 22, 23, 438), + Trans(18, 23, 23, 438), + Trans(18, 24, 23, 438), + Trans(18, 25, 23, 438), + Trans(18, 26, 23, 438), + Trans(18, 30, 23, 438), + Trans(18, 31, 23, 438), + Trans(18, 32, 23, 438), + Trans(18, 33, 23, 438), + Trans(18, 34, 23, 438), + Trans(18, 35, 23, 438), + Trans(18, 36, 23, 438), + Trans(18, 39, 23, 438), + Trans(18, 40, 23, 438), + Trans(18, 41, 23, 438), + Trans(18, 42, 23, 438), + Trans(18, 43, 23, 438), + Trans(18, 44, 23, 438), + Trans(18, 45, 23, 438), + Trans(18, 46, 23, 438), + Trans(18, 47, 23, 438), + Trans(18, 51, 23, 438), + Trans(18, 93, 23, 438), + Trans(18, 102, 23, 438), + Trans(19, 5, 23, 438), + Trans(19, 12, 23, 438), + Trans(19, 14, 23, 438), + Trans(19, 16, 23, 438), + Trans(19, 17, 23, 438), + Trans(19, 18, 23, 438), + Trans(19, 19, 23, 438), + Trans(19, 20, 23, 438), + Trans(19, 21, 23, 438), + Trans(19, 22, 23, 438), + Trans(19, 23, 23, 438), + Trans(19, 24, 23, 438), + Trans(19, 25, 23, 438), + Trans(19, 26, 23, 438), + Trans(19, 30, 23, 438), + Trans(19, 31, 23, 438), + Trans(19, 32, 23, 438), + Trans(19, 33, 23, 438), + Trans(19, 39, 23, 438), + Trans(19, 41, 23, 438), + Trans(19, 42, 23, 438), + Trans(19, 43, 23, 438), + Trans(19, 44, 23, 438), + Trans(19, 45, 23, 438), + Trans(19, 46, 23, 438), + Trans(19, 47, 23, 438), + Trans(19, 51, 23, 438), + Trans(19, 93, 23, 438), + Trans(19, 102, 23, 438), + Trans(20, 5, 23, 438), + Trans(20, 6, 23, 438), + Trans(20, 7, 23, 438), + Trans(20, 8, 23, 438), + Trans(20, 9, 23, 438), + Trans(20, 10, 23, 438), + Trans(20, 11, 23, 438), + Trans(20, 18, 23, 438), + Trans(20, 24, 23, 438), + Trans(20, 25, 23, 438), + Trans(20, 26, 23, 438), + Trans(20, 27, 23, 438), + Trans(20, 30, 23, 438), + Trans(20, 36, 23, 438), + Trans(20, 38, 23, 438), + Trans(20, 39, 23, 438), + Trans(20, 41, 23, 438), + Trans(20, 43, 23, 438), + Trans(20, 48, 23, 438), + Trans(20, 49, 23, 438), + Trans(20, 50, 23, 438), + Trans(20, 53, 23, 438), + Trans(20, 57, 23, 438), + Trans(20, 60, 23, 438), + Trans(20, 61, 23, 438), + Trans(20, 64, 23, 438), + Trans(20, 65, 23, 438), + Trans(20, 66, 23, 438), + Trans(20, 69, 23, 438), + Trans(20, 70, 23, 438), + Trans(20, 71, 23, 438), + Trans(20, 73, 23, 438), + Trans(20, 76, 23, 438), + Trans(20, 77, 23, 438), + Trans(20, 80, 23, 438), + Trans(20, 81, 23, 438), + Trans(20, 83, 23, 438), + Trans(20, 84, 23, 438), + Trans(20, 86, 23, 438), + Trans(20, 88, 23, 438), + Trans(20, 99, 23, 438), + Trans(20, 100, 23, 438), + Trans(20, 104, 23, 438), + Trans(20, 106, 23, 438), + Trans(20, 109, 23, 438), + Trans(20, 110, 23, 438), + Trans(20, 111, 23, 438), + Trans(20, 112, 23, 438), + Trans(21, 5, 23, 438), + Trans(21, 111, 23, 438), + Trans(21, 112, 23, 438), + Trans(22, 5, 23, 438), + Trans(22, 6, 23, 438), + Trans(22, 7, 23, 438), + Trans(22, 8, 23, 438), + Trans(22, 9, 23, 438), + Trans(22, 10, 23, 438), + Trans(22, 11, 23, 438), + Trans(22, 15, 23, 438), + Trans(22, 18, 23, 438), + Trans(22, 24, 23, 438), + Trans(22, 25, 23, 438), + Trans(22, 26, 23, 438), + Trans(22, 27, 23, 438), + Trans(22, 38, 23, 438), + Trans(22, 39, 23, 438), + Trans(22, 41, 23, 438), + Trans(22, 53, 23, 438), + Trans(22, 70, 23, 438), + Trans(22, 76, 23, 438), + Trans(22, 83, 23, 438), + Trans(22, 86, 23, 438), + Trans(22, 88, 23, 438), + Trans(22, 111, 23, 438), + Trans(22, 112, 23, 438), + Trans(24, 5, 23, 438), + Trans(24, 12, 23, 438), + Trans(24, 14, 23, 438), + Trans(24, 16, 23, 438), + Trans(24, 17, 23, 438), + Trans(24, 18, 23, 438), + Trans(24, 19, 23, 438), + Trans(24, 20, 23, 438), + Trans(24, 21, 23, 438), + Trans(24, 22, 23, 438), + Trans(24, 23, 23, 438), + Trans(24, 24, 23, 438), + Trans(24, 25, 23, 438), + Trans(24, 26, 23, 438), + Trans(24, 30, 23, 438), + Trans(24, 31, 23, 438), + Trans(24, 32, 23, 438), + Trans(24, 33, 23, 438), + Trans(24, 39, 23, 438), + Trans(24, 42, 23, 438), + Trans(24, 43, 23, 438), + Trans(24, 44, 23, 438), + Trans(24, 45, 23, 438), + Trans(24, 46, 23, 438), + Trans(24, 47, 23, 438), + Trans(24, 51, 23, 438), + Trans(24, 93, 23, 438), + Trans(24, 102, 23, 438), ], k: 3, }, /* 28 - "ArrayLiteralListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 432), Trans(0, 42, 2, 433)], + transitions: &[Trans(0, 31, 1, 439), Trans(0, 43, 2, 440)], k: 1, }, /* 29 - "ArrayType" */ LookaheadDFA { - prod0: 507, + prod0: 514, transitions: &[], k: 0, }, @@ -2329,72 +2500,72 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 2, 509), - Trans(0, 34, 2, 509), - Trans(0, 39, 1, 508), - Trans(0, 42, 2, 509), - Trans(0, 44, 2, 509), - Trans(0, 45, 2, 509), + Trans(0, 31, 2, 516), + Trans(0, 35, 2, 516), + Trans(0, 40, 1, 515), + Trans(0, 43, 2, 516), + Trans(0, 45, 2, 516), + Trans(0, 46, 2, 516), ], k: 1, }, /* 31 - "As" */ LookaheadDFA { - prod0: 262, + prod0: 265, transitions: &[], k: 0, }, /* 32 - "AsTerm" */ LookaheadDFA { - prod0: 45, + prod0: 46, transitions: &[], k: 0, }, /* 33 - "AsToken" */ LookaheadDFA { - prod0: 155, + prod0: 157, transitions: &[], k: 0, }, /* 34 - "Assign" */ LookaheadDFA { - prod0: 263, + prod0: 266, transitions: &[], k: 0, }, /* 35 - "AssignDeclaration" */ LookaheadDFA { - prod0: 592, + prod0: 599, transitions: &[], k: 0, }, /* 36 - "AssignTerm" */ LookaheadDFA { - prod0: 44, + prod0: 45, transitions: &[], k: 0, }, /* 37 - "AssignToken" */ LookaheadDFA { - prod0: 156, + prod0: 158, transitions: &[], k: 0, }, /* 38 - "Assignment" */ LookaheadDFA { - prod0: 522, + prod0: 529, transitions: &[], k: 0, }, /* 39 - "AssignmentGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 15, 2, 524), Trans(0, 34, 1, 523)], + transitions: &[Trans(0, 15, 2, 531), Trans(0, 35, 1, 530)], k: 1, }, /* 40 - "AssignmentOperator" */ LookaheadDFA { - prod0: 225, + prod0: 227, transitions: &[], k: 0, }, @@ -2406,25 +2577,25 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ }, /* 42 - "AssignmentOperatorToken" */ LookaheadDFA { - prod0: 118, + prod0: 119, transitions: &[], k: 0, }, /* 43 - "Attribute" */ LookaheadDFA { - prod0: 566, + prod0: 573, transitions: &[], k: 0, }, /* 44 - "AttributeItem" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 6, 2, 575), Trans(0, 111, 1, 574)], + transitions: &[Trans(0, 6, 2, 582), Trans(0, 112, 1, 581)], k: 1, }, /* 45 - "AttributeList" */ LookaheadDFA { - prod0: 569, + prod0: 576, transitions: &[], k: 0, }, @@ -2432,72 +2603,72 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 44, 5, -1), + Trans(0, 31, 1, -1), + Trans(0, 45, 5, -1), Trans(1, 5, 4, -1), Trans(1, 6, 2, -1), - Trans(1, 44, 9, -1), - Trans(1, 111, 2, -1), - Trans(2, 5, 3, 570), - Trans(2, 30, 3, 570), - Trans(2, 44, 3, 570), - Trans(4, 6, 3, 570), - Trans(4, 44, 8, 571), - Trans(4, 111, 3, 570), + Trans(1, 45, 9, -1), + Trans(1, 112, 2, -1), + Trans(2, 5, 3, 577), + Trans(2, 31, 3, 577), + Trans(2, 45, 3, 577), + Trans(4, 6, 3, 577), + Trans(4, 45, 8, 578), + Trans(4, 112, 3, 577), Trans(5, 5, 6, -1), - Trans(5, 43, 7, -1), - Trans(6, 43, 8, 571), - Trans(7, 5, 8, 571), - Trans(7, 29, 8, 571), - Trans(7, 35, 8, 571), - Trans(7, 38, 8, 571), - Trans(7, 47, 8, 571), - Trans(7, 48, 8, 571), - Trans(7, 49, 8, 571), - Trans(7, 58, 8, 571), - Trans(7, 59, 8, 571), - Trans(7, 60, 8, 571), - Trans(7, 63, 8, 571), - Trans(7, 64, 8, 571), - Trans(7, 65, 8, 571), - Trans(7, 69, 8, 571), - Trans(7, 70, 8, 571), - Trans(7, 71, 8, 571), - Trans(7, 72, 8, 571), - Trans(7, 76, 8, 571), - Trans(7, 77, 8, 571), - Trans(7, 79, 8, 571), - Trans(7, 80, 8, 571), - Trans(7, 83, 8, 571), - Trans(7, 84, 8, 571), - Trans(7, 88, 8, 571), - Trans(7, 89, 8, 571), - Trans(7, 90, 8, 571), - Trans(7, 103, 8, 571), - Trans(7, 105, 8, 571), - Trans(7, 108, 8, 571), - Trans(7, 109, 8, 571), - Trans(7, 111, 8, 571), - Trans(9, 5, 8, 571), - Trans(9, 43, 8, 571), + Trans(5, 44, 7, -1), + Trans(6, 44, 8, 578), + Trans(7, 5, 8, 578), + Trans(7, 30, 8, 578), + Trans(7, 36, 8, 578), + Trans(7, 39, 8, 578), + Trans(7, 48, 8, 578), + Trans(7, 49, 8, 578), + Trans(7, 50, 8, 578), + Trans(7, 59, 8, 578), + Trans(7, 60, 8, 578), + Trans(7, 61, 8, 578), + Trans(7, 64, 8, 578), + Trans(7, 65, 8, 578), + Trans(7, 66, 8, 578), + Trans(7, 70, 8, 578), + Trans(7, 71, 8, 578), + Trans(7, 72, 8, 578), + Trans(7, 73, 8, 578), + Trans(7, 77, 8, 578), + Trans(7, 78, 8, 578), + Trans(7, 80, 8, 578), + Trans(7, 81, 8, 578), + Trans(7, 84, 8, 578), + Trans(7, 85, 8, 578), + Trans(7, 89, 8, 578), + Trans(7, 90, 8, 578), + Trans(7, 91, 8, 578), + Trans(7, 104, 8, 578), + Trans(7, 106, 8, 578), + Trans(7, 109, 8, 578), + Trans(7, 110, 8, 578), + Trans(7, 112, 8, 578), + Trans(9, 5, 8, 578), + Trans(9, 44, 8, 578), ], k: 3, }, /* 47 - "AttributeListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 572), Trans(0, 44, 2, 573)], + transitions: &[Trans(0, 31, 1, 579), Trans(0, 45, 2, 580)], k: 1, }, /* 48 - "AttributeOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 1, 567), Trans(0, 43, 2, 568)], + transitions: &[Trans(0, 41, 1, 574), Trans(0, 44, 2, 575)], k: 1, }, /* 49 - "BaseLess" */ LookaheadDFA { - prod0: 223, + prod0: 225, transitions: &[], k: 0, }, @@ -2509,13 +2680,13 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ }, /* 51 - "BaseLessToken" */ LookaheadDFA { - prod0: 116, + prod0: 117, transitions: &[], k: 0, }, /* 52 - "Based" */ LookaheadDFA { - prod0: 222, + prod0: 224, transitions: &[], k: 0, }, @@ -2527,115 +2698,115 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ }, /* 54 - "BasedToken" */ LookaheadDFA { - prod0: 115, + prod0: 116, transitions: &[], k: 0, }, /* 55 - "Bit" */ LookaheadDFA { - prod0: 264, + prod0: 267, transitions: &[], k: 0, }, /* 56 - "BitTerm" */ LookaheadDFA { - prod0: 46, + prod0: 47, transitions: &[], k: 0, }, /* 57 - "BitToken" */ LookaheadDFA { - prod0: 157, + prod0: 159, transitions: &[], k: 0, }, /* 58 - "Break" */ LookaheadDFA { - prod0: 265, + prod0: 268, transitions: &[], k: 0, }, /* 59 - "BreakStatement" */ LookaheadDFA { - prod0: 548, + prod0: 555, transitions: &[], k: 0, }, /* 60 - "BreakTerm" */ LookaheadDFA { - prod0: 94, + prod0: 95, transitions: &[], k: 0, }, /* 61 - "BreakToken" */ LookaheadDFA { - prod0: 205, + prod0: 207, transitions: &[], k: 0, }, /* 62 - "Case" */ LookaheadDFA { - prod0: 266, + prod0: 269, transitions: &[], k: 0, }, /* 63 - "CaseExpression" */ LookaheadDFA { - prod0: 442, + prod0: 449, transitions: &[], k: 0, }, /* 64 - "CaseExpressionList" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 29, 2, 448), Trans(0, 30, 1, 447)], + transitions: &[Trans(0, 30, 2, 455), Trans(0, 31, 1, 454)], k: 1, }, /* 65 - "CaseExpressionList0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 1, 443), - Trans(0, 7, 1, 443), - Trans(0, 8, 1, 443), - Trans(0, 9, 1, 443), - Trans(0, 10, 1, 443), - Trans(0, 11, 1, 443), - Trans(0, 18, 1, 443), - Trans(0, 24, 1, 443), - Trans(0, 25, 1, 443), - Trans(0, 26, 1, 443), - Trans(0, 27, 1, 443), - Trans(0, 37, 1, 443), - Trans(0, 38, 1, 443), - Trans(0, 40, 1, 443), - Trans(0, 52, 1, 443), - Trans(0, 56, 2, 446), - Trans(0, 69, 1, 443), - Trans(0, 75, 1, 443), - Trans(0, 82, 1, 443), - Trans(0, 85, 1, 443), - Trans(0, 87, 1, 443), - Trans(0, 110, 1, 443), - Trans(0, 111, 1, 443), + Trans(0, 6, 1, 450), + Trans(0, 7, 1, 450), + Trans(0, 8, 1, 450), + Trans(0, 9, 1, 450), + Trans(0, 10, 1, 450), + Trans(0, 11, 1, 450), + Trans(0, 18, 1, 450), + Trans(0, 24, 1, 450), + Trans(0, 25, 1, 450), + Trans(0, 26, 1, 450), + Trans(0, 27, 1, 450), + Trans(0, 38, 1, 450), + Trans(0, 39, 1, 450), + Trans(0, 41, 1, 450), + Trans(0, 53, 1, 450), + Trans(0, 57, 2, 453), + Trans(0, 70, 1, 450), + Trans(0, 76, 1, 450), + Trans(0, 83, 1, 450), + Trans(0, 86, 1, 450), + Trans(0, 88, 1, 450), + Trans(0, 111, 1, 450), + Trans(0, 112, 1, 450), ], k: 1, }, /* 66 - "CaseExpressionList0List" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 29, 2, 445), Trans(0, 30, 1, 444)], + transitions: &[Trans(0, 30, 2, 452), Trans(0, 31, 1, 451)], k: 1, }, /* 67 - "CaseExpressionOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 449), Trans(0, 42, 2, 450)], + transitions: &[Trans(0, 31, 1, 456), Trans(0, 43, 2, 457)], k: 1, }, /* 68 - "CaseItem" */ LookaheadDFA { - prod0: 557, + prod0: 564, transitions: &[], k: 0, }, @@ -2643,29 +2814,29 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 1, 562), - Trans(0, 7, 1, 562), - Trans(0, 8, 1, 562), - Trans(0, 9, 1, 562), - Trans(0, 10, 1, 562), - Trans(0, 11, 1, 562), - Trans(0, 18, 1, 562), - Trans(0, 24, 1, 562), - Trans(0, 25, 1, 562), - Trans(0, 26, 1, 562), - Trans(0, 27, 1, 562), - Trans(0, 37, 1, 562), - Trans(0, 38, 1, 562), - Trans(0, 40, 1, 562), - Trans(0, 52, 1, 562), - Trans(0, 56, 2, 565), - Trans(0, 69, 1, 562), - Trans(0, 75, 1, 562), - Trans(0, 82, 1, 562), - Trans(0, 85, 1, 562), - Trans(0, 87, 1, 562), - Trans(0, 110, 1, 562), - Trans(0, 111, 1, 562), + Trans(0, 6, 1, 569), + Trans(0, 7, 1, 569), + Trans(0, 8, 1, 569), + Trans(0, 9, 1, 569), + Trans(0, 10, 1, 569), + Trans(0, 11, 1, 569), + Trans(0, 18, 1, 569), + Trans(0, 24, 1, 569), + Trans(0, 25, 1, 569), + Trans(0, 26, 1, 569), + Trans(0, 27, 1, 569), + Trans(0, 38, 1, 569), + Trans(0, 39, 1, 569), + Trans(0, 41, 1, 569), + Trans(0, 53, 1, 569), + Trans(0, 57, 2, 572), + Trans(0, 70, 1, 569), + Trans(0, 76, 1, 569), + Trans(0, 83, 1, 569), + Trans(0, 86, 1, 569), + Trans(0, 88, 1, 569), + Trans(0, 111, 1, 569), + Trans(0, 112, 1, 569), ], k: 1, }, @@ -2673,16 +2844,16 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 38, 2, 559), - Trans(0, 52, 1, 558), - Trans(0, 64, 1, 558), - Trans(0, 68, 1, 558), - Trans(0, 69, 1, 558), - Trans(0, 79, 1, 558), - Trans(0, 98, 1, 558), - Trans(0, 99, 1, 558), - Trans(0, 110, 1, 558), - Trans(0, 111, 1, 558), + Trans(0, 39, 2, 566), + Trans(0, 53, 1, 565), + Trans(0, 65, 1, 565), + Trans(0, 69, 1, 565), + Trans(0, 70, 1, 565), + Trans(0, 80, 1, 565), + Trans(0, 99, 1, 565), + Trans(0, 100, 1, 565), + Trans(0, 111, 1, 565), + Trans(0, 112, 1, 565), ], k: 1, }, @@ -2690,28 +2861,28 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 561), - Trans(0, 52, 1, 560), - Trans(0, 64, 1, 560), - Trans(0, 68, 1, 560), - Trans(0, 69, 1, 560), - Trans(0, 79, 1, 560), - Trans(0, 98, 1, 560), - Trans(0, 99, 1, 560), - Trans(0, 110, 1, 560), - Trans(0, 111, 1, 560), + Trans(0, 43, 2, 568), + Trans(0, 53, 1, 567), + Trans(0, 65, 1, 567), + Trans(0, 69, 1, 567), + Trans(0, 70, 1, 567), + Trans(0, 80, 1, 567), + Trans(0, 99, 1, 567), + Trans(0, 100, 1, 567), + Trans(0, 111, 1, 567), + Trans(0, 112, 1, 567), ], k: 1, }, /* 72 - "CaseItemGroupList" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 29, 2, 564), Trans(0, 30, 1, 563)], + transitions: &[Trans(0, 30, 2, 571), Trans(0, 31, 1, 570)], k: 1, }, /* 73 - "CaseStatement" */ LookaheadDFA { - prod0: 554, + prod0: 561, transitions: &[], k: 0, }, @@ -2719,309 +2890,328 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 1, 555), - Trans(0, 7, 1, 555), - Trans(0, 8, 1, 555), - Trans(0, 9, 1, 555), - Trans(0, 10, 1, 555), - Trans(0, 11, 1, 555), - Trans(0, 18, 1, 555), - Trans(0, 24, 1, 555), - Trans(0, 25, 1, 555), - Trans(0, 26, 1, 555), - Trans(0, 27, 1, 555), - Trans(0, 37, 1, 555), - Trans(0, 38, 1, 555), - Trans(0, 40, 1, 555), - Trans(0, 42, 2, 556), - Trans(0, 52, 1, 555), - Trans(0, 56, 1, 555), - Trans(0, 69, 1, 555), - Trans(0, 75, 1, 555), - Trans(0, 82, 1, 555), - Trans(0, 85, 1, 555), - Trans(0, 87, 1, 555), - Trans(0, 110, 1, 555), - Trans(0, 111, 1, 555), + Trans(0, 6, 1, 562), + Trans(0, 7, 1, 562), + Trans(0, 8, 1, 562), + Trans(0, 9, 1, 562), + Trans(0, 10, 1, 562), + Trans(0, 11, 1, 562), + Trans(0, 18, 1, 562), + Trans(0, 24, 1, 562), + Trans(0, 25, 1, 562), + Trans(0, 26, 1, 562), + Trans(0, 27, 1, 562), + Trans(0, 38, 1, 562), + Trans(0, 39, 1, 562), + Trans(0, 41, 1, 562), + Trans(0, 43, 2, 563), + Trans(0, 53, 1, 562), + Trans(0, 57, 1, 562), + Trans(0, 70, 1, 562), + Trans(0, 76, 1, 562), + Trans(0, 83, 1, 562), + Trans(0, 86, 1, 562), + Trans(0, 88, 1, 562), + Trans(0, 111, 1, 562), + Trans(0, 112, 1, 562), ], k: 1, }, /* 75 - "CaseTerm" */ LookaheadDFA { - prod0: 47, + prod0: 48, transitions: &[], k: 0, }, /* 76 - "CaseToken" */ LookaheadDFA { - prod0: 158, + prod0: 160, transitions: &[], k: 0, }, /* 77 - "Clock" */ LookaheadDFA { - prod0: 267, + prod0: 270, transitions: &[], k: 0, }, /* 78 - "ClockNegedge" */ LookaheadDFA { - prod0: 269, + prod0: 272, transitions: &[], k: 0, }, /* 79 - "ClockNegedgeTerm" */ LookaheadDFA { - prod0: 50, + prod0: 51, transitions: &[], k: 0, }, /* 80 - "ClockNegedgeToken" */ LookaheadDFA { - prod0: 161, + prod0: 163, transitions: &[], k: 0, }, /* 81 - "ClockPosedge" */ LookaheadDFA { - prod0: 268, + prod0: 271, transitions: &[], k: 0, }, /* 82 - "ClockPosedgeTerm" */ LookaheadDFA { - prod0: 49, + prod0: 50, transitions: &[], k: 0, }, /* 83 - "ClockPosedgeToken" */ LookaheadDFA { - prod0: 160, + prod0: 162, transitions: &[], k: 0, }, /* 84 - "ClockTerm" */ LookaheadDFA { - prod0: 48, + prod0: 49, transitions: &[], k: 0, }, /* 85 - "ClockToken" */ LookaheadDFA { - prod0: 159, + prod0: 161, transitions: &[], k: 0, }, /* 86 - "Colon" */ LookaheadDFA { - prod0: 238, + prod0: 240, transitions: &[], k: 0, }, /* 87 - "ColonColon" */ LookaheadDFA { - prod0: 239, + prod0: 242, transitions: &[], k: 0, }, - /* 88 - "ColonColonTerm" */ + /* 88 - "ColonColonLAngle" */ + LookaheadDFA { + prod0: 241, + transitions: &[], + k: 0, + }, + /* 89 - "ColonColonLAngleTerm" */ LookaheadDFA { prod0: 23, transitions: &[], k: 0, }, - /* 89 - "ColonColonToken" */ + /* 90 - "ColonColonLAngleToken" */ LookaheadDFA { - prod0: 132, + prod0: 133, transitions: &[], k: 0, }, - /* 90 - "ColonTerm" */ + /* 91 - "ColonColonTerm" */ LookaheadDFA { prod0: 24, transitions: &[], k: 0, }, - /* 91 - "ColonToken" */ + /* 92 - "ColonColonToken" */ LookaheadDFA { - prod0: 131, + prod0: 134, transitions: &[], k: 0, }, - /* 92 - "Comma" */ + /* 93 - "ColonTerm" */ LookaheadDFA { - prod0: 240, + prod0: 25, transitions: &[], k: 0, }, - /* 93 - "CommaTerm" */ + /* 94 - "ColonToken" */ LookaheadDFA { - prod0: 25, + prod0: 132, transitions: &[], k: 0, }, - /* 94 - "CommaToken" */ + /* 95 - "Comma" */ LookaheadDFA { - prod0: 133, + prod0: 243, transitions: &[], k: 0, }, - /* 95 - "Comments" */ + /* 96 - "CommaTerm" */ LookaheadDFA { - prod0: 108, + prod0: 26, + transitions: &[], + k: 0, + }, + /* 97 - "CommaToken" */ + LookaheadDFA { + prod0: 135, + transitions: &[], + k: 0, + }, + /* 98 - "Comments" */ + LookaheadDFA { + prod0: 109, transitions: &[], k: 0, }, - /* 96 - "CommentsOpt" */ + /* 99 - "CommentsOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 0, 2, 110), - Trans(0, 5, 1, 109), - Trans(0, 6, 2, 110), - Trans(0, 7, 2, 110), - Trans(0, 8, 2, 110), - Trans(0, 9, 2, 110), - Trans(0, 10, 2, 110), - Trans(0, 11, 2, 110), - Trans(0, 12, 2, 110), - Trans(0, 13, 2, 110), - Trans(0, 14, 2, 110), - Trans(0, 15, 2, 110), - Trans(0, 16, 2, 110), - Trans(0, 17, 2, 110), - Trans(0, 18, 2, 110), - Trans(0, 19, 2, 110), - Trans(0, 20, 2, 110), - Trans(0, 21, 2, 110), - Trans(0, 22, 2, 110), - Trans(0, 23, 2, 110), - Trans(0, 24, 2, 110), - Trans(0, 25, 2, 110), - Trans(0, 26, 2, 110), - Trans(0, 27, 2, 110), - Trans(0, 28, 2, 110), - Trans(0, 29, 2, 110), - Trans(0, 30, 2, 110), - Trans(0, 31, 2, 110), - Trans(0, 32, 2, 110), - Trans(0, 33, 2, 110), - Trans(0, 34, 2, 110), - Trans(0, 35, 2, 110), - Trans(0, 36, 2, 110), - Trans(0, 37, 2, 110), - Trans(0, 38, 2, 110), - Trans(0, 39, 2, 110), - Trans(0, 40, 2, 110), - Trans(0, 41, 2, 110), - Trans(0, 42, 2, 110), - Trans(0, 43, 2, 110), - Trans(0, 44, 2, 110), - Trans(0, 45, 2, 110), - Trans(0, 46, 2, 110), - Trans(0, 47, 2, 110), - Trans(0, 48, 2, 110), - Trans(0, 49, 2, 110), - Trans(0, 50, 2, 110), - Trans(0, 51, 2, 110), - Trans(0, 52, 2, 110), - Trans(0, 53, 2, 110), - Trans(0, 54, 2, 110), - Trans(0, 55, 2, 110), - Trans(0, 56, 2, 110), - Trans(0, 57, 2, 110), - Trans(0, 58, 2, 110), - Trans(0, 59, 2, 110), - Trans(0, 60, 2, 110), - Trans(0, 61, 2, 110), - Trans(0, 62, 2, 110), - Trans(0, 63, 2, 110), - Trans(0, 64, 2, 110), - Trans(0, 65, 2, 110), - Trans(0, 66, 2, 110), - Trans(0, 67, 2, 110), - Trans(0, 68, 2, 110), - Trans(0, 69, 2, 110), - Trans(0, 70, 2, 110), - Trans(0, 71, 2, 110), - Trans(0, 72, 2, 110), - Trans(0, 73, 2, 110), - Trans(0, 74, 2, 110), - Trans(0, 75, 2, 110), - Trans(0, 76, 2, 110), - Trans(0, 77, 2, 110), - Trans(0, 78, 2, 110), - Trans(0, 79, 2, 110), - Trans(0, 80, 2, 110), - Trans(0, 81, 2, 110), - Trans(0, 82, 2, 110), - Trans(0, 83, 2, 110), - Trans(0, 84, 2, 110), - Trans(0, 85, 2, 110), - Trans(0, 86, 2, 110), - Trans(0, 87, 2, 110), - Trans(0, 88, 2, 110), - Trans(0, 89, 2, 110), - Trans(0, 90, 2, 110), - Trans(0, 91, 2, 110), - Trans(0, 92, 2, 110), - Trans(0, 93, 2, 110), - Trans(0, 94, 2, 110), - Trans(0, 95, 2, 110), - Trans(0, 96, 2, 110), - Trans(0, 97, 2, 110), - Trans(0, 98, 2, 110), - Trans(0, 99, 2, 110), - Trans(0, 100, 2, 110), - Trans(0, 101, 2, 110), - Trans(0, 102, 2, 110), - Trans(0, 103, 2, 110), - Trans(0, 104, 2, 110), - Trans(0, 105, 2, 110), - Trans(0, 106, 2, 110), - Trans(0, 107, 2, 110), - Trans(0, 108, 2, 110), - Trans(0, 109, 2, 110), - Trans(0, 110, 2, 110), - Trans(0, 111, 2, 110), + Trans(0, 0, 2, 111), + Trans(0, 5, 1, 110), + Trans(0, 6, 2, 111), + Trans(0, 7, 2, 111), + Trans(0, 8, 2, 111), + Trans(0, 9, 2, 111), + Trans(0, 10, 2, 111), + Trans(0, 11, 2, 111), + Trans(0, 12, 2, 111), + Trans(0, 13, 2, 111), + Trans(0, 14, 2, 111), + Trans(0, 15, 2, 111), + Trans(0, 16, 2, 111), + Trans(0, 17, 2, 111), + Trans(0, 18, 2, 111), + Trans(0, 19, 2, 111), + Trans(0, 20, 2, 111), + Trans(0, 21, 2, 111), + Trans(0, 22, 2, 111), + Trans(0, 23, 2, 111), + Trans(0, 24, 2, 111), + Trans(0, 25, 2, 111), + Trans(0, 26, 2, 111), + Trans(0, 27, 2, 111), + Trans(0, 28, 2, 111), + Trans(0, 29, 2, 111), + Trans(0, 30, 2, 111), + Trans(0, 31, 2, 111), + Trans(0, 32, 2, 111), + Trans(0, 33, 2, 111), + Trans(0, 34, 2, 111), + Trans(0, 35, 2, 111), + Trans(0, 36, 2, 111), + Trans(0, 37, 2, 111), + Trans(0, 38, 2, 111), + Trans(0, 39, 2, 111), + Trans(0, 40, 2, 111), + Trans(0, 41, 2, 111), + Trans(0, 42, 2, 111), + Trans(0, 43, 2, 111), + Trans(0, 44, 2, 111), + Trans(0, 45, 2, 111), + Trans(0, 46, 2, 111), + Trans(0, 47, 2, 111), + Trans(0, 48, 2, 111), + Trans(0, 49, 2, 111), + Trans(0, 50, 2, 111), + Trans(0, 51, 2, 111), + Trans(0, 52, 2, 111), + Trans(0, 53, 2, 111), + Trans(0, 54, 2, 111), + Trans(0, 55, 2, 111), + Trans(0, 56, 2, 111), + Trans(0, 57, 2, 111), + Trans(0, 58, 2, 111), + Trans(0, 59, 2, 111), + Trans(0, 60, 2, 111), + Trans(0, 61, 2, 111), + Trans(0, 62, 2, 111), + Trans(0, 63, 2, 111), + Trans(0, 64, 2, 111), + Trans(0, 65, 2, 111), + Trans(0, 66, 2, 111), + Trans(0, 67, 2, 111), + Trans(0, 68, 2, 111), + Trans(0, 69, 2, 111), + Trans(0, 70, 2, 111), + Trans(0, 71, 2, 111), + Trans(0, 72, 2, 111), + Trans(0, 73, 2, 111), + Trans(0, 74, 2, 111), + Trans(0, 75, 2, 111), + Trans(0, 76, 2, 111), + Trans(0, 77, 2, 111), + Trans(0, 78, 2, 111), + Trans(0, 79, 2, 111), + Trans(0, 80, 2, 111), + Trans(0, 81, 2, 111), + Trans(0, 82, 2, 111), + Trans(0, 83, 2, 111), + Trans(0, 84, 2, 111), + Trans(0, 85, 2, 111), + Trans(0, 86, 2, 111), + Trans(0, 87, 2, 111), + Trans(0, 88, 2, 111), + Trans(0, 89, 2, 111), + Trans(0, 90, 2, 111), + Trans(0, 91, 2, 111), + Trans(0, 92, 2, 111), + Trans(0, 93, 2, 111), + Trans(0, 94, 2, 111), + Trans(0, 95, 2, 111), + Trans(0, 96, 2, 111), + Trans(0, 97, 2, 111), + Trans(0, 98, 2, 111), + Trans(0, 99, 2, 111), + Trans(0, 100, 2, 111), + Trans(0, 101, 2, 111), + Trans(0, 102, 2, 111), + Trans(0, 103, 2, 111), + Trans(0, 104, 2, 111), + Trans(0, 105, 2, 111), + Trans(0, 106, 2, 111), + Trans(0, 107, 2, 111), + Trans(0, 108, 2, 111), + Trans(0, 109, 2, 111), + Trans(0, 110, 2, 111), + Trans(0, 111, 2, 111), + Trans(0, 112, 2, 111), ], k: 1, }, - /* 97 - "CommentsTerm" */ + /* 100 - "CommentsTerm" */ LookaheadDFA { prod0: 0, transitions: &[], k: 0, }, - /* 98 - "ConcatenationItem" */ + /* 101 - "ConcatenationItem" */ LookaheadDFA { - prod0: 426, + prod0: 433, transitions: &[], k: 0, }, - /* 99 - "ConcatenationItemOpt" */ + /* 102 - "ConcatenationItemOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 2, 428), - Trans(0, 42, 2, 428), - Trans(0, 92, 1, 427), + Trans(0, 31, 2, 435), + Trans(0, 43, 2, 435), + Trans(0, 93, 1, 434), ], k: 1, }, - /* 100 - "ConcatenationList" */ + /* 103 - "ConcatenationList" */ LookaheadDFA { - prod0: 421, + prod0: 428, transitions: &[], k: 0, }, - /* 101 - "ConcatenationListList" */ + /* 104 - "ConcatenationListList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 8, -1), - Trans(1, 5, 7, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 9, -1), + Trans(1, 5, 8, -1), Trans(1, 6, 2, -1), Trans(1, 7, 2, -1), Trans(1, 8, 2, -1), @@ -3033,2334 +3223,2374 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(1, 25, 4, -1), Trans(1, 26, 4, -1), Trans(1, 27, 4, -1), - Trans(1, 37, 5, -1), - Trans(1, 38, 4, -1), - Trans(1, 40, 4, -1), - Trans(1, 42, 22, -1), - Trans(1, 52, 4, -1), - Trans(1, 69, 4, -1), - Trans(1, 75, 4, -1), - Trans(1, 82, 2, -1), - Trans(1, 85, 2, -1), - Trans(1, 87, 4, -1), - Trans(1, 110, 6, -1), + Trans(1, 38, 5, -1), + Trans(1, 39, 4, -1), + Trans(1, 41, 4, -1), + Trans(1, 43, 23, -1), + Trans(1, 53, 4, -1), + Trans(1, 70, 4, -1), + Trans(1, 76, 4, -1), + Trans(1, 83, 2, -1), + Trans(1, 86, 2, -1), + Trans(1, 88, 4, -1), Trans(1, 111, 6, -1), - Trans(2, 5, 3, 422), - Trans(2, 16, 3, 422), - Trans(2, 17, 3, 422), - Trans(2, 18, 3, 422), - Trans(2, 19, 3, 422), - Trans(2, 20, 3, 422), - Trans(2, 21, 3, 422), - Trans(2, 22, 3, 422), - Trans(2, 23, 3, 422), - Trans(2, 24, 3, 422), - Trans(2, 25, 3, 422), - Trans(2, 26, 3, 422), - Trans(2, 30, 3, 422), - Trans(2, 42, 3, 422), - Trans(2, 46, 3, 422), - Trans(2, 50, 3, 422), - Trans(2, 92, 3, 422), - Trans(4, 5, 3, 422), - Trans(4, 6, 3, 422), - Trans(4, 7, 3, 422), - Trans(4, 8, 3, 422), - Trans(4, 9, 3, 422), - Trans(4, 10, 3, 422), - Trans(4, 11, 3, 422), - Trans(4, 18, 3, 422), - Trans(4, 24, 3, 422), - Trans(4, 25, 3, 422), - Trans(4, 26, 3, 422), - Trans(4, 27, 3, 422), - Trans(4, 37, 3, 422), - Trans(4, 38, 3, 422), - Trans(4, 40, 3, 422), - Trans(4, 52, 3, 422), - Trans(4, 69, 3, 422), - Trans(4, 75, 3, 422), - Trans(4, 82, 3, 422), - Trans(4, 85, 3, 422), - Trans(4, 87, 3, 422), - Trans(4, 110, 3, 422), - Trans(4, 111, 3, 422), - Trans(5, 5, 3, 422), - Trans(5, 6, 3, 422), - Trans(5, 7, 3, 422), - Trans(5, 8, 3, 422), - Trans(5, 9, 3, 422), - Trans(5, 10, 3, 422), - Trans(5, 11, 3, 422), - Trans(5, 18, 3, 422), - Trans(5, 24, 3, 422), - Trans(5, 25, 3, 422), - Trans(5, 26, 3, 422), - Trans(5, 27, 3, 422), - Trans(5, 37, 3, 422), - Trans(5, 38, 3, 422), - Trans(5, 40, 3, 422), - Trans(5, 52, 3, 422), - Trans(5, 56, 3, 422), - Trans(5, 69, 3, 422), - Trans(5, 75, 3, 422), - Trans(5, 82, 3, 422), - Trans(5, 85, 3, 422), - Trans(5, 87, 3, 422), - Trans(5, 110, 3, 422), - Trans(5, 111, 3, 422), - Trans(6, 5, 3, 422), - Trans(6, 16, 3, 422), - Trans(6, 17, 3, 422), - Trans(6, 18, 3, 422), - Trans(6, 19, 3, 422), - Trans(6, 20, 3, 422), - Trans(6, 21, 3, 422), - Trans(6, 22, 3, 422), - Trans(6, 23, 3, 422), - Trans(6, 24, 3, 422), - Trans(6, 25, 3, 422), - Trans(6, 26, 3, 422), - Trans(6, 28, 3, 422), - Trans(6, 30, 3, 422), - Trans(6, 33, 3, 422), - Trans(6, 39, 3, 422), - Trans(6, 40, 3, 422), - Trans(6, 42, 3, 422), - Trans(6, 46, 3, 422), - Trans(6, 50, 3, 422), - Trans(6, 92, 3, 422), - Trans(7, 6, 3, 422), - Trans(7, 7, 3, 422), - Trans(7, 8, 3, 422), - Trans(7, 9, 3, 422), - Trans(7, 10, 3, 422), - Trans(7, 11, 3, 422), - Trans(7, 18, 3, 422), - Trans(7, 24, 3, 422), - Trans(7, 25, 3, 422), - Trans(7, 26, 3, 422), - Trans(7, 27, 3, 422), - Trans(7, 37, 3, 422), - Trans(7, 38, 3, 422), - Trans(7, 40, 3, 422), - Trans(7, 42, 21, 423), - Trans(7, 52, 3, 422), - Trans(7, 69, 3, 422), - Trans(7, 75, 3, 422), - Trans(7, 82, 3, 422), - Trans(7, 85, 3, 422), - Trans(7, 87, 3, 422), - Trans(7, 110, 3, 422), - Trans(7, 111, 3, 422), - Trans(8, 5, 9, -1), - Trans(8, 12, 10, -1), - Trans(8, 14, 10, -1), - Trans(8, 16, 10, -1), - Trans(8, 17, 10, -1), - Trans(8, 18, 10, -1), - Trans(8, 19, 10, -1), - Trans(8, 20, 10, -1), - Trans(8, 21, 10, -1), - Trans(8, 22, 10, -1), - Trans(8, 23, 10, -1), - Trans(8, 24, 10, -1), - Trans(8, 25, 10, -1), - Trans(8, 26, 10, -1), - Trans(8, 29, 11, -1), - Trans(8, 30, 12, -1), - Trans(8, 31, 10, -1), - Trans(8, 32, 10, -1), - Trans(8, 38, 13, -1), - Trans(8, 41, 14, -1), - Trans(8, 42, 15, -1), - Trans(8, 43, 16, -1), - Trans(8, 44, 17, -1), - Trans(8, 45, 18, -1), - Trans(8, 46, 10, -1), - Trans(8, 50, 19, -1), - Trans(8, 92, 10, -1), - Trans(8, 101, 20, -1), - Trans(9, 12, 21, 423), - Trans(9, 14, 21, 423), - Trans(9, 16, 21, 423), - Trans(9, 17, 21, 423), - Trans(9, 18, 21, 423), - Trans(9, 19, 21, 423), - Trans(9, 20, 21, 423), - Trans(9, 21, 21, 423), - Trans(9, 22, 21, 423), - Trans(9, 23, 21, 423), - Trans(9, 24, 21, 423), - Trans(9, 25, 21, 423), - Trans(9, 26, 21, 423), - Trans(9, 29, 21, 423), - Trans(9, 30, 21, 423), - Trans(9, 31, 21, 423), - Trans(9, 32, 21, 423), - Trans(9, 38, 21, 423), - Trans(9, 41, 21, 423), - Trans(9, 42, 21, 423), - Trans(9, 43, 21, 423), - Trans(9, 44, 21, 423), - Trans(9, 45, 21, 423), - Trans(9, 46, 21, 423), - Trans(9, 50, 21, 423), - Trans(9, 92, 21, 423), - Trans(9, 101, 21, 423), - Trans(10, 5, 21, 423), - Trans(10, 6, 21, 423), - Trans(10, 7, 21, 423), - Trans(10, 8, 21, 423), - Trans(10, 9, 21, 423), - Trans(10, 10, 21, 423), - Trans(10, 11, 21, 423), - Trans(10, 18, 21, 423), - Trans(10, 24, 21, 423), - Trans(10, 25, 21, 423), - Trans(10, 26, 21, 423), - Trans(10, 27, 21, 423), - Trans(10, 37, 21, 423), - Trans(10, 38, 21, 423), - Trans(10, 40, 21, 423), - Trans(10, 52, 21, 423), - Trans(10, 69, 21, 423), - Trans(10, 75, 21, 423), - Trans(10, 82, 21, 423), - Trans(10, 85, 21, 423), - Trans(10, 87, 21, 423), - Trans(10, 110, 21, 423), - Trans(10, 111, 21, 423), - Trans(11, 5, 21, 423), - Trans(11, 6, 21, 423), - Trans(11, 7, 21, 423), - Trans(11, 8, 21, 423), - Trans(11, 9, 21, 423), - Trans(11, 10, 21, 423), - Trans(11, 11, 21, 423), - Trans(11, 18, 21, 423), - Trans(11, 24, 21, 423), - Trans(11, 25, 21, 423), - Trans(11, 26, 21, 423), - Trans(11, 27, 21, 423), - Trans(11, 37, 21, 423), - Trans(11, 38, 21, 423), - Trans(11, 40, 21, 423), - Trans(11, 52, 21, 423), - Trans(11, 64, 21, 423), - Trans(11, 68, 21, 423), - Trans(11, 69, 21, 423), - Trans(11, 75, 21, 423), - Trans(11, 79, 21, 423), - Trans(11, 82, 21, 423), - Trans(11, 85, 21, 423), - Trans(11, 87, 21, 423), - Trans(11, 98, 21, 423), - Trans(11, 99, 21, 423), - Trans(11, 110, 21, 423), - Trans(11, 111, 21, 423), - Trans(12, 5, 21, 423), - Trans(12, 6, 21, 423), - Trans(12, 7, 21, 423), - Trans(12, 8, 21, 423), - Trans(12, 9, 21, 423), - Trans(12, 10, 21, 423), - Trans(12, 11, 21, 423), - Trans(12, 18, 21, 423), - Trans(12, 24, 21, 423), - Trans(12, 25, 21, 423), - Trans(12, 26, 21, 423), - Trans(12, 27, 21, 423), - Trans(12, 35, 21, 423), - Trans(12, 37, 21, 423), - Trans(12, 38, 21, 423), - Trans(12, 40, 21, 423), - Trans(12, 42, 21, 423), - Trans(12, 44, 21, 423), - Trans(12, 52, 21, 423), - Trans(12, 56, 21, 423), - Trans(12, 69, 21, 423), - Trans(12, 75, 21, 423), - Trans(12, 80, 21, 423), - Trans(12, 82, 21, 423), - Trans(12, 85, 21, 423), - Trans(12, 87, 21, 423), - Trans(12, 89, 21, 423), - Trans(12, 110, 21, 423), - Trans(12, 111, 21, 423), - Trans(13, 5, 21, 423), - Trans(13, 6, 21, 423), - Trans(13, 7, 21, 423), - Trans(13, 8, 21, 423), - Trans(13, 9, 21, 423), - Trans(13, 10, 21, 423), - Trans(13, 11, 21, 423), - Trans(13, 18, 21, 423), - Trans(13, 24, 21, 423), - Trans(13, 25, 21, 423), - Trans(13, 26, 21, 423), - Trans(13, 27, 21, 423), - Trans(13, 29, 21, 423), - Trans(13, 35, 21, 423), - Trans(13, 37, 21, 423), - Trans(13, 38, 21, 423), - Trans(13, 40, 21, 423), - Trans(13, 42, 21, 423), - Trans(13, 47, 21, 423), - Trans(13, 48, 21, 423), - Trans(13, 49, 21, 423), - Trans(13, 52, 21, 423), - Trans(13, 56, 21, 423), - Trans(13, 59, 21, 423), - Trans(13, 63, 21, 423), - Trans(13, 64, 21, 423), - Trans(13, 65, 21, 423), - Trans(13, 68, 21, 423), - Trans(13, 69, 21, 423), - Trans(13, 70, 21, 423), - Trans(13, 72, 21, 423), - Trans(13, 75, 21, 423), - Trans(13, 76, 21, 423), - Trans(13, 79, 21, 423), - Trans(13, 80, 21, 423), - Trans(13, 82, 21, 423), - Trans(13, 83, 21, 423), - Trans(13, 85, 21, 423), - Trans(13, 87, 21, 423), - Trans(13, 98, 21, 423), - Trans(13, 99, 21, 423), - Trans(13, 103, 21, 423), - Trans(13, 105, 21, 423), - Trans(13, 108, 21, 423), - Trans(13, 109, 21, 423), - Trans(13, 110, 21, 423), - Trans(13, 111, 21, 423), - Trans(14, 5, 21, 423), - Trans(14, 30, 21, 423), - Trans(14, 34, 21, 423), - Trans(14, 38, 21, 423), - Trans(14, 39, 21, 423), - Trans(14, 42, 21, 423), - Trans(14, 44, 21, 423), - Trans(14, 45, 21, 423), - Trans(14, 78, 21, 423), - Trans(15, 5, 21, 423), - Trans(15, 12, 21, 423), - Trans(15, 14, 21, 423), - Trans(15, 16, 21, 423), - Trans(15, 17, 21, 423), - Trans(15, 18, 21, 423), - Trans(15, 19, 21, 423), - Trans(15, 20, 21, 423), - Trans(15, 21, 21, 423), - Trans(15, 22, 21, 423), - Trans(15, 23, 21, 423), - Trans(15, 24, 21, 423), - Trans(15, 25, 21, 423), - Trans(15, 26, 21, 423), - Trans(15, 29, 21, 423), - Trans(15, 30, 21, 423), - Trans(15, 31, 21, 423), - Trans(15, 32, 21, 423), - Trans(15, 35, 21, 423), - Trans(15, 38, 21, 423), - Trans(15, 41, 21, 423), - Trans(15, 42, 21, 423), - Trans(15, 43, 21, 423), - Trans(15, 44, 21, 423), - Trans(15, 45, 21, 423), - Trans(15, 46, 21, 423), - Trans(15, 47, 21, 423), - Trans(15, 48, 21, 423), - Trans(15, 49, 21, 423), - Trans(15, 50, 21, 423), - Trans(15, 57, 21, 423), - Trans(15, 59, 21, 423), - Trans(15, 60, 21, 423), - Trans(15, 63, 21, 423), - Trans(15, 64, 21, 423), - Trans(15, 65, 21, 423), - Trans(15, 69, 21, 423), - Trans(15, 70, 21, 423), - Trans(15, 72, 21, 423), - Trans(15, 76, 21, 423), - Trans(15, 79, 21, 423), - Trans(15, 80, 21, 423), - Trans(15, 83, 21, 423), - Trans(15, 92, 21, 423), - Trans(15, 101, 21, 423), - Trans(15, 103, 21, 423), - Trans(15, 105, 21, 423), - Trans(15, 108, 21, 423), - Trans(15, 109, 21, 423), - Trans(16, 5, 21, 423), - Trans(16, 12, 21, 423), - Trans(16, 14, 21, 423), - Trans(16, 15, 21, 423), - Trans(16, 16, 21, 423), - Trans(16, 17, 21, 423), - Trans(16, 18, 21, 423), - Trans(16, 19, 21, 423), - Trans(16, 20, 21, 423), - Trans(16, 21, 21, 423), - Trans(16, 22, 21, 423), - Trans(16, 23, 21, 423), - Trans(16, 24, 21, 423), - Trans(16, 25, 21, 423), - Trans(16, 26, 21, 423), - Trans(16, 29, 21, 423), - Trans(16, 30, 21, 423), - Trans(16, 31, 21, 423), - Trans(16, 32, 21, 423), - Trans(16, 33, 21, 423), - Trans(16, 34, 21, 423), - Trans(16, 35, 21, 423), - Trans(16, 38, 21, 423), - Trans(16, 39, 21, 423), - Trans(16, 40, 21, 423), - Trans(16, 41, 21, 423), - Trans(16, 42, 21, 423), - Trans(16, 43, 21, 423), - Trans(16, 44, 21, 423), - Trans(16, 45, 21, 423), - Trans(16, 46, 21, 423), - Trans(16, 50, 21, 423), - Trans(16, 92, 21, 423), - Trans(16, 101, 21, 423), - Trans(17, 5, 21, 423), - Trans(17, 12, 21, 423), - Trans(17, 14, 21, 423), - Trans(17, 16, 21, 423), - Trans(17, 17, 21, 423), - Trans(17, 18, 21, 423), - Trans(17, 19, 21, 423), - Trans(17, 20, 21, 423), - Trans(17, 21, 21, 423), - Trans(17, 22, 21, 423), - Trans(17, 23, 21, 423), - Trans(17, 24, 21, 423), - Trans(17, 25, 21, 423), - Trans(17, 26, 21, 423), - Trans(17, 29, 21, 423), - Trans(17, 30, 21, 423), - Trans(17, 31, 21, 423), - Trans(17, 32, 21, 423), - Trans(17, 38, 21, 423), - Trans(17, 40, 21, 423), - Trans(17, 41, 21, 423), - Trans(17, 42, 21, 423), - Trans(17, 43, 21, 423), - Trans(17, 44, 21, 423), - Trans(17, 45, 21, 423), - Trans(17, 46, 21, 423), - Trans(17, 50, 21, 423), - Trans(17, 92, 21, 423), - Trans(17, 101, 21, 423), - Trans(18, 5, 21, 423), - Trans(18, 6, 21, 423), - Trans(18, 7, 21, 423), - Trans(18, 8, 21, 423), - Trans(18, 9, 21, 423), - Trans(18, 10, 21, 423), - Trans(18, 11, 21, 423), - Trans(18, 18, 21, 423), - Trans(18, 24, 21, 423), - Trans(18, 25, 21, 423), - Trans(18, 26, 21, 423), - Trans(18, 27, 21, 423), - Trans(18, 29, 21, 423), - Trans(18, 35, 21, 423), - Trans(18, 37, 21, 423), - Trans(18, 38, 21, 423), - Trans(18, 40, 21, 423), - Trans(18, 42, 21, 423), - Trans(18, 47, 21, 423), - Trans(18, 48, 21, 423), - Trans(18, 49, 21, 423), - Trans(18, 52, 21, 423), - Trans(18, 56, 21, 423), - Trans(18, 59, 21, 423), - Trans(18, 60, 21, 423), - Trans(18, 63, 21, 423), - Trans(18, 64, 21, 423), - Trans(18, 65, 21, 423), - Trans(18, 68, 21, 423), - Trans(18, 69, 21, 423), - Trans(18, 70, 21, 423), - Trans(18, 72, 21, 423), - Trans(18, 75, 21, 423), - Trans(18, 76, 21, 423), - Trans(18, 79, 21, 423), - Trans(18, 80, 21, 423), - Trans(18, 82, 21, 423), - Trans(18, 83, 21, 423), - Trans(18, 85, 21, 423), - Trans(18, 87, 21, 423), - Trans(18, 98, 21, 423), - Trans(18, 99, 21, 423), - Trans(18, 103, 21, 423), - Trans(18, 105, 21, 423), - Trans(18, 108, 21, 423), - Trans(18, 109, 21, 423), - Trans(18, 110, 21, 423), - Trans(18, 111, 21, 423), - Trans(19, 5, 21, 423), - Trans(19, 110, 21, 423), - Trans(19, 111, 21, 423), - Trans(20, 5, 21, 423), - Trans(20, 6, 21, 423), - Trans(20, 7, 21, 423), - Trans(20, 8, 21, 423), - Trans(20, 9, 21, 423), - Trans(20, 10, 21, 423), - Trans(20, 11, 21, 423), - Trans(20, 15, 21, 423), - Trans(20, 18, 21, 423), - Trans(20, 24, 21, 423), - Trans(20, 25, 21, 423), - Trans(20, 26, 21, 423), - Trans(20, 27, 21, 423), - Trans(20, 37, 21, 423), - Trans(20, 38, 21, 423), - Trans(20, 40, 21, 423), - Trans(20, 52, 21, 423), - Trans(20, 69, 21, 423), - Trans(20, 75, 21, 423), - Trans(20, 82, 21, 423), - Trans(20, 85, 21, 423), - Trans(20, 87, 21, 423), - Trans(20, 110, 21, 423), - Trans(20, 111, 21, 423), - Trans(22, 5, 21, 423), - Trans(22, 12, 21, 423), - Trans(22, 14, 21, 423), - Trans(22, 16, 21, 423), - Trans(22, 17, 21, 423), - Trans(22, 18, 21, 423), - Trans(22, 19, 21, 423), - Trans(22, 20, 21, 423), - Trans(22, 21, 21, 423), - Trans(22, 22, 21, 423), - Trans(22, 23, 21, 423), - Trans(22, 24, 21, 423), - Trans(22, 25, 21, 423), - Trans(22, 26, 21, 423), - Trans(22, 29, 21, 423), - Trans(22, 30, 21, 423), - Trans(22, 31, 21, 423), - Trans(22, 32, 21, 423), - Trans(22, 38, 21, 423), - Trans(22, 41, 21, 423), - Trans(22, 42, 21, 423), - Trans(22, 43, 21, 423), - Trans(22, 44, 21, 423), - Trans(22, 45, 21, 423), - Trans(22, 46, 21, 423), - Trans(22, 50, 21, 423), - Trans(22, 92, 21, 423), - Trans(22, 101, 21, 423), + Trans(1, 112, 7, -1), + Trans(2, 5, 3, 429), + Trans(2, 16, 3, 429), + Trans(2, 17, 3, 429), + Trans(2, 18, 3, 429), + Trans(2, 19, 3, 429), + Trans(2, 20, 3, 429), + Trans(2, 21, 3, 429), + Trans(2, 22, 3, 429), + Trans(2, 23, 3, 429), + Trans(2, 24, 3, 429), + Trans(2, 25, 3, 429), + Trans(2, 26, 3, 429), + Trans(2, 31, 3, 429), + Trans(2, 43, 3, 429), + Trans(2, 47, 3, 429), + Trans(2, 51, 3, 429), + Trans(2, 93, 3, 429), + Trans(4, 5, 3, 429), + Trans(4, 6, 3, 429), + Trans(4, 7, 3, 429), + Trans(4, 8, 3, 429), + Trans(4, 9, 3, 429), + Trans(4, 10, 3, 429), + Trans(4, 11, 3, 429), + Trans(4, 18, 3, 429), + Trans(4, 24, 3, 429), + Trans(4, 25, 3, 429), + Trans(4, 26, 3, 429), + Trans(4, 27, 3, 429), + Trans(4, 38, 3, 429), + Trans(4, 39, 3, 429), + Trans(4, 41, 3, 429), + Trans(4, 53, 3, 429), + Trans(4, 70, 3, 429), + Trans(4, 76, 3, 429), + Trans(4, 83, 3, 429), + Trans(4, 86, 3, 429), + Trans(4, 88, 3, 429), + Trans(4, 111, 3, 429), + Trans(4, 112, 3, 429), + Trans(5, 5, 3, 429), + Trans(5, 6, 3, 429), + Trans(5, 7, 3, 429), + Trans(5, 8, 3, 429), + Trans(5, 9, 3, 429), + Trans(5, 10, 3, 429), + Trans(5, 11, 3, 429), + Trans(5, 18, 3, 429), + Trans(5, 24, 3, 429), + Trans(5, 25, 3, 429), + Trans(5, 26, 3, 429), + Trans(5, 27, 3, 429), + Trans(5, 38, 3, 429), + Trans(5, 39, 3, 429), + Trans(5, 41, 3, 429), + Trans(5, 53, 3, 429), + Trans(5, 57, 3, 429), + Trans(5, 70, 3, 429), + Trans(5, 76, 3, 429), + Trans(5, 83, 3, 429), + Trans(5, 86, 3, 429), + Trans(5, 88, 3, 429), + Trans(5, 111, 3, 429), + Trans(5, 112, 3, 429), + Trans(6, 5, 3, 429), + Trans(6, 16, 3, 429), + Trans(6, 17, 3, 429), + Trans(6, 18, 3, 429), + Trans(6, 19, 3, 429), + Trans(6, 20, 3, 429), + Trans(6, 21, 3, 429), + Trans(6, 22, 3, 429), + Trans(6, 23, 3, 429), + Trans(6, 24, 3, 429), + Trans(6, 25, 3, 429), + Trans(6, 26, 3, 429), + Trans(6, 29, 3, 429), + Trans(6, 31, 3, 429), + Trans(6, 34, 3, 429), + Trans(6, 40, 3, 429), + Trans(6, 41, 3, 429), + Trans(6, 43, 3, 429), + Trans(6, 47, 3, 429), + Trans(6, 51, 3, 429), + Trans(6, 93, 3, 429), + Trans(7, 5, 3, 429), + Trans(7, 16, 3, 429), + Trans(7, 17, 3, 429), + Trans(7, 18, 3, 429), + Trans(7, 19, 3, 429), + Trans(7, 20, 3, 429), + Trans(7, 21, 3, 429), + Trans(7, 22, 3, 429), + Trans(7, 23, 3, 429), + Trans(7, 24, 3, 429), + Trans(7, 25, 3, 429), + Trans(7, 26, 3, 429), + Trans(7, 28, 3, 429), + Trans(7, 29, 3, 429), + Trans(7, 31, 3, 429), + Trans(7, 34, 3, 429), + Trans(7, 40, 3, 429), + Trans(7, 41, 3, 429), + Trans(7, 43, 3, 429), + Trans(7, 47, 3, 429), + Trans(7, 51, 3, 429), + Trans(7, 93, 3, 429), + Trans(8, 6, 3, 429), + Trans(8, 7, 3, 429), + Trans(8, 8, 3, 429), + Trans(8, 9, 3, 429), + Trans(8, 10, 3, 429), + Trans(8, 11, 3, 429), + Trans(8, 18, 3, 429), + Trans(8, 24, 3, 429), + Trans(8, 25, 3, 429), + Trans(8, 26, 3, 429), + Trans(8, 27, 3, 429), + Trans(8, 38, 3, 429), + Trans(8, 39, 3, 429), + Trans(8, 41, 3, 429), + Trans(8, 43, 22, 430), + Trans(8, 53, 3, 429), + Trans(8, 70, 3, 429), + Trans(8, 76, 3, 429), + Trans(8, 83, 3, 429), + Trans(8, 86, 3, 429), + Trans(8, 88, 3, 429), + Trans(8, 111, 3, 429), + Trans(8, 112, 3, 429), + Trans(9, 5, 10, -1), + Trans(9, 12, 11, -1), + Trans(9, 14, 11, -1), + Trans(9, 16, 11, -1), + Trans(9, 17, 11, -1), + Trans(9, 18, 11, -1), + Trans(9, 19, 11, -1), + Trans(9, 20, 11, -1), + Trans(9, 21, 11, -1), + Trans(9, 22, 11, -1), + Trans(9, 23, 11, -1), + Trans(9, 24, 11, -1), + Trans(9, 25, 11, -1), + Trans(9, 26, 11, -1), + Trans(9, 30, 12, -1), + Trans(9, 31, 13, -1), + Trans(9, 32, 11, -1), + Trans(9, 33, 11, -1), + Trans(9, 39, 14, -1), + Trans(9, 42, 15, -1), + Trans(9, 43, 16, -1), + Trans(9, 44, 17, -1), + Trans(9, 45, 18, -1), + Trans(9, 46, 19, -1), + Trans(9, 47, 11, -1), + Trans(9, 51, 20, -1), + Trans(9, 93, 11, -1), + Trans(9, 102, 21, -1), + Trans(10, 12, 22, 430), + Trans(10, 14, 22, 430), + Trans(10, 16, 22, 430), + Trans(10, 17, 22, 430), + Trans(10, 18, 22, 430), + Trans(10, 19, 22, 430), + Trans(10, 20, 22, 430), + Trans(10, 21, 22, 430), + Trans(10, 22, 22, 430), + Trans(10, 23, 22, 430), + Trans(10, 24, 22, 430), + Trans(10, 25, 22, 430), + Trans(10, 26, 22, 430), + Trans(10, 30, 22, 430), + Trans(10, 31, 22, 430), + Trans(10, 32, 22, 430), + Trans(10, 33, 22, 430), + Trans(10, 39, 22, 430), + Trans(10, 42, 22, 430), + Trans(10, 43, 22, 430), + Trans(10, 44, 22, 430), + Trans(10, 45, 22, 430), + Trans(10, 46, 22, 430), + Trans(10, 47, 22, 430), + Trans(10, 51, 22, 430), + Trans(10, 93, 22, 430), + Trans(10, 102, 22, 430), + Trans(11, 5, 22, 430), + Trans(11, 6, 22, 430), + Trans(11, 7, 22, 430), + Trans(11, 8, 22, 430), + Trans(11, 9, 22, 430), + Trans(11, 10, 22, 430), + Trans(11, 11, 22, 430), + Trans(11, 18, 22, 430), + Trans(11, 24, 22, 430), + Trans(11, 25, 22, 430), + Trans(11, 26, 22, 430), + Trans(11, 27, 22, 430), + Trans(11, 38, 22, 430), + Trans(11, 39, 22, 430), + Trans(11, 41, 22, 430), + Trans(11, 53, 22, 430), + Trans(11, 70, 22, 430), + Trans(11, 76, 22, 430), + Trans(11, 83, 22, 430), + Trans(11, 86, 22, 430), + Trans(11, 88, 22, 430), + Trans(11, 111, 22, 430), + Trans(11, 112, 22, 430), + Trans(12, 5, 22, 430), + Trans(12, 6, 22, 430), + Trans(12, 7, 22, 430), + Trans(12, 8, 22, 430), + Trans(12, 9, 22, 430), + Trans(12, 10, 22, 430), + Trans(12, 11, 22, 430), + Trans(12, 18, 22, 430), + Trans(12, 24, 22, 430), + Trans(12, 25, 22, 430), + Trans(12, 26, 22, 430), + Trans(12, 27, 22, 430), + Trans(12, 38, 22, 430), + Trans(12, 39, 22, 430), + Trans(12, 41, 22, 430), + Trans(12, 53, 22, 430), + Trans(12, 65, 22, 430), + Trans(12, 69, 22, 430), + Trans(12, 70, 22, 430), + Trans(12, 76, 22, 430), + Trans(12, 80, 22, 430), + Trans(12, 83, 22, 430), + Trans(12, 86, 22, 430), + Trans(12, 88, 22, 430), + Trans(12, 99, 22, 430), + Trans(12, 100, 22, 430), + Trans(12, 111, 22, 430), + Trans(12, 112, 22, 430), + Trans(13, 5, 22, 430), + Trans(13, 6, 22, 430), + Trans(13, 7, 22, 430), + Trans(13, 8, 22, 430), + Trans(13, 9, 22, 430), + Trans(13, 10, 22, 430), + Trans(13, 11, 22, 430), + Trans(13, 18, 22, 430), + Trans(13, 24, 22, 430), + Trans(13, 25, 22, 430), + Trans(13, 26, 22, 430), + Trans(13, 27, 22, 430), + Trans(13, 36, 22, 430), + Trans(13, 38, 22, 430), + Trans(13, 39, 22, 430), + Trans(13, 41, 22, 430), + Trans(13, 43, 22, 430), + Trans(13, 45, 22, 430), + Trans(13, 53, 22, 430), + Trans(13, 57, 22, 430), + Trans(13, 70, 22, 430), + Trans(13, 76, 22, 430), + Trans(13, 81, 22, 430), + Trans(13, 83, 22, 430), + Trans(13, 86, 22, 430), + Trans(13, 88, 22, 430), + Trans(13, 90, 22, 430), + Trans(13, 111, 22, 430), + Trans(13, 112, 22, 430), + Trans(14, 5, 22, 430), + Trans(14, 6, 22, 430), + Trans(14, 7, 22, 430), + Trans(14, 8, 22, 430), + Trans(14, 9, 22, 430), + Trans(14, 10, 22, 430), + Trans(14, 11, 22, 430), + Trans(14, 18, 22, 430), + Trans(14, 24, 22, 430), + Trans(14, 25, 22, 430), + Trans(14, 26, 22, 430), + Trans(14, 27, 22, 430), + Trans(14, 30, 22, 430), + Trans(14, 36, 22, 430), + Trans(14, 38, 22, 430), + Trans(14, 39, 22, 430), + Trans(14, 41, 22, 430), + Trans(14, 43, 22, 430), + Trans(14, 48, 22, 430), + Trans(14, 49, 22, 430), + Trans(14, 50, 22, 430), + Trans(14, 53, 22, 430), + Trans(14, 57, 22, 430), + Trans(14, 60, 22, 430), + Trans(14, 64, 22, 430), + Trans(14, 65, 22, 430), + Trans(14, 66, 22, 430), + Trans(14, 69, 22, 430), + Trans(14, 70, 22, 430), + Trans(14, 71, 22, 430), + Trans(14, 73, 22, 430), + Trans(14, 76, 22, 430), + Trans(14, 77, 22, 430), + Trans(14, 80, 22, 430), + Trans(14, 81, 22, 430), + Trans(14, 83, 22, 430), + Trans(14, 84, 22, 430), + Trans(14, 86, 22, 430), + Trans(14, 88, 22, 430), + Trans(14, 99, 22, 430), + Trans(14, 100, 22, 430), + Trans(14, 104, 22, 430), + Trans(14, 106, 22, 430), + Trans(14, 109, 22, 430), + Trans(14, 110, 22, 430), + Trans(14, 111, 22, 430), + Trans(14, 112, 22, 430), + Trans(15, 5, 22, 430), + Trans(15, 31, 22, 430), + Trans(15, 35, 22, 430), + Trans(15, 39, 22, 430), + Trans(15, 40, 22, 430), + Trans(15, 43, 22, 430), + Trans(15, 45, 22, 430), + Trans(15, 46, 22, 430), + Trans(15, 79, 22, 430), + Trans(16, 5, 22, 430), + Trans(16, 12, 22, 430), + Trans(16, 14, 22, 430), + Trans(16, 16, 22, 430), + Trans(16, 17, 22, 430), + Trans(16, 18, 22, 430), + Trans(16, 19, 22, 430), + Trans(16, 20, 22, 430), + Trans(16, 21, 22, 430), + Trans(16, 22, 22, 430), + Trans(16, 23, 22, 430), + Trans(16, 24, 22, 430), + Trans(16, 25, 22, 430), + Trans(16, 26, 22, 430), + Trans(16, 30, 22, 430), + Trans(16, 31, 22, 430), + Trans(16, 32, 22, 430), + Trans(16, 33, 22, 430), + Trans(16, 36, 22, 430), + Trans(16, 39, 22, 430), + Trans(16, 42, 22, 430), + Trans(16, 43, 22, 430), + Trans(16, 44, 22, 430), + Trans(16, 45, 22, 430), + Trans(16, 46, 22, 430), + Trans(16, 47, 22, 430), + Trans(16, 48, 22, 430), + Trans(16, 49, 22, 430), + Trans(16, 50, 22, 430), + Trans(16, 51, 22, 430), + Trans(16, 58, 22, 430), + Trans(16, 60, 22, 430), + Trans(16, 61, 22, 430), + Trans(16, 64, 22, 430), + Trans(16, 65, 22, 430), + Trans(16, 66, 22, 430), + Trans(16, 70, 22, 430), + Trans(16, 71, 22, 430), + Trans(16, 73, 22, 430), + Trans(16, 77, 22, 430), + Trans(16, 80, 22, 430), + Trans(16, 81, 22, 430), + Trans(16, 84, 22, 430), + Trans(16, 93, 22, 430), + Trans(16, 102, 22, 430), + Trans(16, 104, 22, 430), + Trans(16, 106, 22, 430), + Trans(16, 109, 22, 430), + Trans(16, 110, 22, 430), + Trans(17, 5, 22, 430), + Trans(17, 12, 22, 430), + Trans(17, 14, 22, 430), + Trans(17, 15, 22, 430), + Trans(17, 16, 22, 430), + Trans(17, 17, 22, 430), + Trans(17, 18, 22, 430), + Trans(17, 19, 22, 430), + Trans(17, 20, 22, 430), + Trans(17, 21, 22, 430), + Trans(17, 22, 22, 430), + Trans(17, 23, 22, 430), + Trans(17, 24, 22, 430), + Trans(17, 25, 22, 430), + Trans(17, 26, 22, 430), + Trans(17, 30, 22, 430), + Trans(17, 31, 22, 430), + Trans(17, 32, 22, 430), + Trans(17, 33, 22, 430), + Trans(17, 34, 22, 430), + Trans(17, 35, 22, 430), + Trans(17, 36, 22, 430), + Trans(17, 39, 22, 430), + Trans(17, 40, 22, 430), + Trans(17, 41, 22, 430), + Trans(17, 42, 22, 430), + Trans(17, 43, 22, 430), + Trans(17, 44, 22, 430), + Trans(17, 45, 22, 430), + Trans(17, 46, 22, 430), + Trans(17, 47, 22, 430), + Trans(17, 51, 22, 430), + Trans(17, 93, 22, 430), + Trans(17, 102, 22, 430), + Trans(18, 5, 22, 430), + Trans(18, 12, 22, 430), + Trans(18, 14, 22, 430), + Trans(18, 16, 22, 430), + Trans(18, 17, 22, 430), + Trans(18, 18, 22, 430), + Trans(18, 19, 22, 430), + Trans(18, 20, 22, 430), + Trans(18, 21, 22, 430), + Trans(18, 22, 22, 430), + Trans(18, 23, 22, 430), + Trans(18, 24, 22, 430), + Trans(18, 25, 22, 430), + Trans(18, 26, 22, 430), + Trans(18, 30, 22, 430), + Trans(18, 31, 22, 430), + Trans(18, 32, 22, 430), + Trans(18, 33, 22, 430), + Trans(18, 39, 22, 430), + Trans(18, 41, 22, 430), + Trans(18, 42, 22, 430), + Trans(18, 43, 22, 430), + Trans(18, 44, 22, 430), + Trans(18, 45, 22, 430), + Trans(18, 46, 22, 430), + Trans(18, 47, 22, 430), + Trans(18, 51, 22, 430), + Trans(18, 93, 22, 430), + Trans(18, 102, 22, 430), + Trans(19, 5, 22, 430), + Trans(19, 6, 22, 430), + Trans(19, 7, 22, 430), + Trans(19, 8, 22, 430), + Trans(19, 9, 22, 430), + Trans(19, 10, 22, 430), + Trans(19, 11, 22, 430), + Trans(19, 18, 22, 430), + Trans(19, 24, 22, 430), + Trans(19, 25, 22, 430), + Trans(19, 26, 22, 430), + Trans(19, 27, 22, 430), + Trans(19, 30, 22, 430), + Trans(19, 36, 22, 430), + Trans(19, 38, 22, 430), + Trans(19, 39, 22, 430), + Trans(19, 41, 22, 430), + Trans(19, 43, 22, 430), + Trans(19, 48, 22, 430), + Trans(19, 49, 22, 430), + Trans(19, 50, 22, 430), + Trans(19, 53, 22, 430), + Trans(19, 57, 22, 430), + Trans(19, 60, 22, 430), + Trans(19, 61, 22, 430), + Trans(19, 64, 22, 430), + Trans(19, 65, 22, 430), + Trans(19, 66, 22, 430), + Trans(19, 69, 22, 430), + Trans(19, 70, 22, 430), + Trans(19, 71, 22, 430), + Trans(19, 73, 22, 430), + Trans(19, 76, 22, 430), + Trans(19, 77, 22, 430), + Trans(19, 80, 22, 430), + Trans(19, 81, 22, 430), + Trans(19, 83, 22, 430), + Trans(19, 84, 22, 430), + Trans(19, 86, 22, 430), + Trans(19, 88, 22, 430), + Trans(19, 99, 22, 430), + Trans(19, 100, 22, 430), + Trans(19, 104, 22, 430), + Trans(19, 106, 22, 430), + Trans(19, 109, 22, 430), + Trans(19, 110, 22, 430), + Trans(19, 111, 22, 430), + Trans(19, 112, 22, 430), + Trans(20, 5, 22, 430), + Trans(20, 111, 22, 430), + Trans(20, 112, 22, 430), + Trans(21, 5, 22, 430), + Trans(21, 6, 22, 430), + Trans(21, 7, 22, 430), + Trans(21, 8, 22, 430), + Trans(21, 9, 22, 430), + Trans(21, 10, 22, 430), + Trans(21, 11, 22, 430), + Trans(21, 15, 22, 430), + Trans(21, 18, 22, 430), + Trans(21, 24, 22, 430), + Trans(21, 25, 22, 430), + Trans(21, 26, 22, 430), + Trans(21, 27, 22, 430), + Trans(21, 38, 22, 430), + Trans(21, 39, 22, 430), + Trans(21, 41, 22, 430), + Trans(21, 53, 22, 430), + Trans(21, 70, 22, 430), + Trans(21, 76, 22, 430), + Trans(21, 83, 22, 430), + Trans(21, 86, 22, 430), + Trans(21, 88, 22, 430), + Trans(21, 111, 22, 430), + Trans(21, 112, 22, 430), + Trans(23, 5, 22, 430), + Trans(23, 12, 22, 430), + Trans(23, 14, 22, 430), + Trans(23, 16, 22, 430), + Trans(23, 17, 22, 430), + Trans(23, 18, 22, 430), + Trans(23, 19, 22, 430), + Trans(23, 20, 22, 430), + Trans(23, 21, 22, 430), + Trans(23, 22, 22, 430), + Trans(23, 23, 22, 430), + Trans(23, 24, 22, 430), + Trans(23, 25, 22, 430), + Trans(23, 26, 22, 430), + Trans(23, 30, 22, 430), + Trans(23, 31, 22, 430), + Trans(23, 32, 22, 430), + Trans(23, 33, 22, 430), + Trans(23, 39, 22, 430), + Trans(23, 42, 22, 430), + Trans(23, 43, 22, 430), + Trans(23, 44, 22, 430), + Trans(23, 45, 22, 430), + Trans(23, 46, 22, 430), + Trans(23, 47, 22, 430), + Trans(23, 51, 22, 430), + Trans(23, 93, 22, 430), + Trans(23, 102, 22, 430), ], k: 3, }, - /* 102 - "ConcatenationListOpt" */ + /* 105 - "ConcatenationListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 424), Trans(0, 42, 2, 425)], + transitions: &[Trans(0, 31, 1, 431), Trans(0, 43, 2, 432)], k: 1, }, - /* 103 - "Defaul" */ + /* 106 - "Defaul" */ LookaheadDFA { - prod0: 270, + prod0: 273, transitions: &[], k: 0, }, - /* 104 - "DefaultTerm" */ + /* 107 - "DefaultTerm" */ LookaheadDFA { - prod0: 51, + prod0: 52, transitions: &[], k: 0, }, - /* 105 - "DefaultToken" */ + /* 108 - "DefaultToken" */ LookaheadDFA { - prod0: 162, + prod0: 164, transitions: &[], k: 0, }, - /* 106 - "DescriptionGroup" */ + /* 109 - "DescriptionGroup" */ LookaheadDFA { - prod0: 860, + prod0: 892, transitions: &[], k: 0, }, - /* 107 - "DescriptionGroupGroup" */ + /* 110 - "DescriptionGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 38, 1, 861), - Trans(0, 58, 2, 864), - Trans(0, 70, 2, 864), - Trans(0, 71, 2, 864), - Trans(0, 77, 2, 864), - Trans(0, 84, 2, 864), - Trans(0, 88, 2, 864), - Trans(0, 90, 2, 864), + Trans(0, 39, 1, 893), + Trans(0, 59, 2, 896), + Trans(0, 71, 2, 896), + Trans(0, 72, 2, 896), + Trans(0, 78, 2, 896), + Trans(0, 85, 2, 896), + Trans(0, 89, 2, 896), + Trans(0, 91, 2, 896), ], k: 1, }, - /* 108 - "DescriptionGroupGroupList" */ + /* 111 - "DescriptionGroupGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 862), - Trans(0, 38, 1, 862), - Trans(0, 42, 2, 863), - Trans(0, 58, 1, 862), - Trans(0, 70, 1, 862), - Trans(0, 71, 1, 862), - Trans(0, 77, 1, 862), - Trans(0, 84, 1, 862), - Trans(0, 88, 1, 862), - Trans(0, 90, 1, 862), + Trans(0, 36, 1, 894), + Trans(0, 39, 1, 894), + Trans(0, 43, 2, 895), + Trans(0, 59, 1, 894), + Trans(0, 71, 1, 894), + Trans(0, 72, 1, 894), + Trans(0, 78, 1, 894), + Trans(0, 85, 1, 894), + Trans(0, 89, 1, 894), + Trans(0, 91, 1, 894), ], k: 1, }, - /* 109 - "DescriptionGroupList" */ + /* 112 - "DescriptionGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 865), - Trans(0, 38, 2, 866), - Trans(0, 58, 2, 866), - Trans(0, 70, 2, 866), - Trans(0, 71, 2, 866), - Trans(0, 77, 2, 866), - Trans(0, 84, 2, 866), - Trans(0, 88, 2, 866), - Trans(0, 90, 2, 866), + Trans(0, 36, 1, 897), + Trans(0, 39, 2, 898), + Trans(0, 59, 2, 898), + Trans(0, 71, 2, 898), + Trans(0, 72, 2, 898), + Trans(0, 78, 2, 898), + Trans(0, 85, 2, 898), + Trans(0, 89, 2, 898), + Trans(0, 91, 2, 898), ], k: 1, }, - /* 110 - "DescriptionItem" */ + /* 113 - "DescriptionItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 58, 22, -1), - Trans(0, 70, 18, -1), - Trans(0, 71, 26, -1), - Trans(0, 77, 8, -1), - Trans(0, 84, 4, -1), - Trans(0, 88, 13, -1), - Trans(0, 90, 1, -1), + Trans(0, 59, 23, -1), + Trans(0, 71, 18, -1), + Trans(0, 72, 27, -1), + Trans(0, 78, 8, -1), + Trans(0, 85, 4, -1), + Trans(0, 89, 13, -1), + Trans(0, 91, 1, -1), Trans(1, 5, 6, -1), - Trans(1, 77, 9, -1), - Trans(1, 84, 2, -1), - Trans(1, 88, 14, -1), - Trans(2, 5, 3, 867), - Trans(2, 111, 3, 867), + Trans(1, 78, 9, -1), + Trans(1, 85, 2, -1), + Trans(1, 89, 14, -1), + Trans(2, 5, 3, 899), + Trans(2, 112, 3, 899), Trans(4, 5, 7, -1), - Trans(4, 111, 5, -1), - Trans(5, 5, 3, 867), - Trans(5, 35, 3, 867), - Trans(5, 38, 3, 867), - Trans(5, 40, 3, 867), - Trans(6, 77, 10, 868), - Trans(6, 84, 3, 867), - Trans(6, 88, 15, 869), - Trans(7, 111, 3, 867), + Trans(4, 112, 5, -1), + Trans(5, 5, 3, 899), + Trans(5, 28, 3, 899), + Trans(5, 36, 3, 899), + Trans(5, 39, 3, 899), + Trans(5, 41, 3, 899), + Trans(6, 78, 10, 900), + Trans(6, 85, 3, 899), + Trans(6, 89, 15, 901), + Trans(7, 112, 3, 899), Trans(8, 5, 11, -1), - Trans(8, 111, 12, -1), - Trans(9, 5, 10, 868), - Trans(9, 111, 10, 868), - Trans(11, 111, 10, 868), - Trans(12, 5, 10, 868), - Trans(12, 35, 10, 868), - Trans(12, 38, 10, 868), + Trans(8, 112, 12, -1), + Trans(9, 5, 10, 900), + Trans(9, 112, 10, 900), + Trans(11, 112, 10, 900), + Trans(12, 5, 10, 900), + Trans(12, 28, 10, 900), + Trans(12, 36, 10, 900), + Trans(12, 39, 10, 900), Trans(13, 5, 16, -1), - Trans(13, 111, 17, -1), - Trans(14, 5, 15, 869), - Trans(14, 111, 15, 869), - Trans(16, 111, 15, 869), - Trans(17, 5, 15, 869), - Trans(17, 38, 15, 869), + Trans(13, 112, 17, -1), + Trans(14, 5, 15, 901), + Trans(14, 112, 15, 901), + Trans(16, 112, 15, 901), + Trans(17, 5, 15, 901), + Trans(17, 28, 15, 901), + Trans(17, 39, 15, 901), Trans(18, 5, 19, -1), - Trans(18, 110, 20, -1), Trans(18, 111, 20, -1), - Trans(19, 110, 21, 870), - Trans(19, 111, 21, 870), - Trans(20, 5, 21, 870), - Trans(20, 28, 21, 870), - Trans(20, 45, 21, 870), - Trans(22, 5, 23, -1), - Trans(22, 40, 24, -1), - Trans(23, 40, 25, 871), - Trans(24, 5, 25, 871), - Trans(24, 111, 25, 871), - Trans(26, 5, 27, -1), - Trans(26, 40, 28, -1), - Trans(27, 40, 29, 872), - Trans(28, 5, 29, 872), - Trans(28, 111, 29, 872), + Trans(18, 112, 21, -1), + Trans(19, 111, 22, 902), + Trans(19, 112, 22, 902), + Trans(20, 5, 22, 902), + Trans(20, 29, 22, 902), + Trans(20, 46, 22, 902), + Trans(21, 5, 22, 902), + Trans(21, 28, 22, 902), + Trans(21, 29, 22, 902), + Trans(21, 46, 22, 902), + Trans(23, 5, 24, -1), + Trans(23, 41, 25, -1), + Trans(24, 41, 26, 903), + Trans(25, 5, 26, 903), + Trans(25, 112, 26, 903), + Trans(27, 5, 28, -1), + Trans(27, 41, 29, -1), + Trans(28, 41, 30, 904), + Trans(29, 5, 30, 904), + Trans(29, 112, 30, 904), ], k: 3, }, - /* 111 - "Direction" */ + /* 114 - "Direction" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 73, 3, 715), - Trans(0, 74, 1, 713), - Trans(0, 83, 5, 717), - Trans(0, 86, 2, 714), - Trans(0, 91, 4, 716), + Trans(0, 74, 3, 739), + Trans(0, 75, 1, 737), + Trans(0, 84, 5, 741), + Trans(0, 87, 2, 738), + Trans(0, 92, 4, 740), ], k: 1, }, - /* 112 - "DollarIdentifier" */ + /* 115 - "DollarIdentifier" */ LookaheadDFA { - prod0: 323, + prod0: 326, transitions: &[], k: 0, }, - /* 113 - "DollarIdentifierTerm" */ + /* 116 - "DollarIdentifierTerm" */ LookaheadDFA { - prod0: 105, + prod0: 106, transitions: &[], k: 0, }, - /* 114 - "DollarIdentifierToken" */ + /* 117 - "DollarIdentifierToken" */ LookaheadDFA { - prod0: 216, + prod0: 218, transitions: &[], k: 0, }, - /* 115 - "Dot" */ + /* 118 - "Dot" */ LookaheadDFA { - prod0: 243, + prod0: 246, transitions: &[], k: 0, }, - /* 116 - "DotDot" */ + /* 119 - "DotDot" */ LookaheadDFA { - prod0: 241, + prod0: 244, transitions: &[], k: 0, }, - /* 117 - "DotDotEqu" */ + /* 120 - "DotDotEqu" */ LookaheadDFA { - prod0: 242, + prod0: 245, transitions: &[], k: 0, }, - /* 118 - "DotDotEquTerm" */ + /* 121 - "DotDotEquTerm" */ LookaheadDFA { - prod0: 26, + prod0: 27, transitions: &[], k: 0, }, - /* 119 - "DotDotEquToken" */ + /* 122 - "DotDotEquToken" */ LookaheadDFA { - prod0: 135, + prod0: 137, transitions: &[], k: 0, }, - /* 120 - "DotDotTerm" */ + /* 123 - "DotDotTerm" */ LookaheadDFA { - prod0: 27, + prod0: 28, transitions: &[], k: 0, }, - /* 121 - "DotDotToken" */ + /* 124 - "DotDotToken" */ LookaheadDFA { - prod0: 134, + prod0: 136, transitions: &[], k: 0, }, - /* 122 - "DotTerm" */ + /* 125 - "DotTerm" */ LookaheadDFA { - prod0: 28, + prod0: 29, transitions: &[], k: 0, }, - /* 123 - "DotToken" */ + /* 126 - "DotToken" */ LookaheadDFA { - prod0: 136, + prod0: 138, transitions: &[], k: 0, }, - /* 124 - "Else" */ + /* 127 - "Else" */ LookaheadDFA { - prod0: 271, + prod0: 274, transitions: &[], k: 0, }, - /* 125 - "ElseTerm" */ + /* 128 - "ElseTerm" */ LookaheadDFA { - prod0: 52, + prod0: 53, transitions: &[], k: 0, }, - /* 126 - "ElseToken" */ + /* 129 - "ElseToken" */ LookaheadDFA { - prod0: 163, + prod0: 165, transitions: &[], k: 0, }, - /* 127 - "Embed" */ + /* 130 - "Embed" */ LookaheadDFA { - prod0: 272, + prod0: 275, transitions: &[], k: 0, }, - /* 128 - "EmbedContent" */ + /* 131 - "EmbedContent" */ LookaheadDFA { - prod0: 851, + prod0: 883, transitions: &[], k: 0, }, - /* 129 - "EmbedContentToken" */ + /* 132 - "EmbedContentToken" */ LookaheadDFA { - prod0: 852, + prod0: 884, transitions: &[], k: 0, }, - /* 130 - "EmbedContentTokenList" */ + /* 133 - "EmbedContentTokenList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 38, 1, 853), - Trans(0, 42, 2, 854), - Trans(0, 112, 1, 853), + Trans(0, 39, 1, 885), + Trans(0, 43, 2, 886), + Trans(0, 113, 1, 885), ], k: 1, }, - /* 131 - "EmbedDeclaration" */ + /* 134 - "EmbedDeclaration" */ LookaheadDFA { - prod0: 850, + prod0: 882, transitions: &[], k: 0, }, - /* 132 - "EmbedItem" */ + /* 135 - "EmbedItem" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 38, 1, 855), Trans(0, 112, 2, 858)], + transitions: &[Trans(0, 39, 1, 887), Trans(0, 113, 2, 890)], k: 1, }, - /* 133 - "EmbedItemList" */ + /* 136 - "EmbedItemList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 38, 1, 856), - Trans(0, 42, 2, 857), - Trans(0, 112, 1, 856), + Trans(0, 39, 1, 888), + Trans(0, 43, 2, 889), + Trans(0, 113, 1, 888), ], k: 1, }, - /* 134 - "EmbedTerm" */ + /* 137 - "EmbedTerm" */ LookaheadDFA { - prod0: 53, + prod0: 54, transitions: &[], k: 0, }, - /* 135 - "EmbedToken" */ + /* 138 - "EmbedToken" */ LookaheadDFA { - prod0: 164, + prod0: 166, transitions: &[], k: 0, }, - /* 136 - "Enum" */ + /* 139 - "Enum" */ LookaheadDFA { - prod0: 273, + prod0: 276, transitions: &[], k: 0, }, - /* 137 - "EnumDeclaration" */ + /* 140 - "EnumDeclaration" */ LookaheadDFA { - prod0: 605, + prod0: 612, transitions: &[], k: 0, }, - /* 138 - "EnumGroup" */ + /* 141 - "EnumGroup" */ LookaheadDFA { - prod0: 611, + prod0: 618, transitions: &[], k: 0, }, - /* 139 - "EnumGroupGroup" */ + /* 142 - "EnumGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 38, 1, 612), Trans(0, 111, 2, 613)], + transitions: &[Trans(0, 39, 1, 619), Trans(0, 112, 2, 620)], k: 1, }, - /* 140 - "EnumGroupList" */ + /* 143 - "EnumGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 614), - Trans(0, 38, 2, 615), - Trans(0, 111, 2, 615), + Trans(0, 36, 1, 621), + Trans(0, 39, 2, 622), + Trans(0, 112, 2, 622), ], k: 1, }, - /* 141 - "EnumItem" */ + /* 144 - "EnumItem" */ LookaheadDFA { - prod0: 616, + prod0: 623, transitions: &[], k: 0, }, - /* 142 - "EnumItemOpt" */ + /* 145 - "EnumItemOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 2, 618), - Trans(0, 34, 1, 617), - Trans(0, 42, 2, 618), + Trans(0, 31, 2, 625), + Trans(0, 35, 1, 624), + Trans(0, 43, 2, 625), ], k: 1, }, - /* 143 - "EnumList" */ + /* 146 - "EnumList" */ LookaheadDFA { - prod0: 606, + prod0: 613, transitions: &[], k: 0, }, - /* 144 - "EnumListList" */ + /* 147 - "EnumListList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 7, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 7, -1), Trans(1, 5, 6, -1), - Trans(1, 35, 2, -1), - Trans(1, 38, 4, -1), - Trans(1, 42, 20, -1), - Trans(1, 111, 5, -1), - Trans(2, 5, 3, 607), - Trans(2, 39, 3, 607), - Trans(4, 5, 3, 607), - Trans(4, 35, 3, 607), - Trans(4, 38, 3, 607), - Trans(4, 111, 3, 607), - Trans(5, 5, 3, 607), - Trans(5, 30, 3, 607), - Trans(5, 34, 3, 607), - Trans(5, 42, 3, 607), - Trans(6, 35, 3, 607), - Trans(6, 38, 3, 607), - Trans(6, 42, 19, 608), - Trans(6, 111, 3, 607), + Trans(1, 36, 2, -1), + Trans(1, 39, 4, -1), + Trans(1, 43, 20, -1), + Trans(1, 112, 5, -1), + Trans(2, 5, 3, 614), + Trans(2, 40, 3, 614), + Trans(4, 5, 3, 614), + Trans(4, 36, 3, 614), + Trans(4, 39, 3, 614), + Trans(4, 112, 3, 614), + Trans(5, 5, 3, 614), + Trans(5, 31, 3, 614), + Trans(5, 35, 3, 614), + Trans(5, 43, 3, 614), + Trans(6, 36, 3, 614), + Trans(6, 39, 3, 614), + Trans(6, 43, 19, 615), + Trans(6, 112, 3, 614), Trans(7, 5, 8, -1), - Trans(7, 29, 9, -1), - Trans(7, 30, 10, -1), - Trans(7, 35, 11, -1), - Trans(7, 38, 12, -1), - Trans(7, 42, 13, -1), - Trans(7, 47, 14, -1), - Trans(7, 48, 15, -1), - Trans(7, 49, 9, -1), - Trans(7, 59, 9, -1), - Trans(7, 60, 16, -1), - Trans(7, 63, 14, -1), - Trans(7, 64, 9, -1), + Trans(7, 30, 9, -1), + Trans(7, 31, 10, -1), + Trans(7, 36, 11, -1), + Trans(7, 39, 12, -1), + Trans(7, 43, 13, -1), + Trans(7, 48, 14, -1), + Trans(7, 49, 15, -1), + Trans(7, 50, 9, -1), + Trans(7, 60, 9, -1), + Trans(7, 61, 16, -1), + Trans(7, 64, 14, -1), Trans(7, 65, 9, -1), - Trans(7, 69, 17, -1), - Trans(7, 70, 18, -1), - Trans(7, 72, 14, -1), - Trans(7, 76, 9, -1), - Trans(7, 79, 9, -1), + Trans(7, 66, 9, -1), + Trans(7, 70, 17, -1), + Trans(7, 71, 18, -1), + Trans(7, 73, 14, -1), + Trans(7, 77, 9, -1), Trans(7, 80, 9, -1), - Trans(7, 83, 9, -1), - Trans(7, 103, 9, -1), - Trans(7, 105, 9, -1), - Trans(7, 108, 9, -1), + Trans(7, 81, 9, -1), + Trans(7, 84, 9, -1), + Trans(7, 104, 9, -1), + Trans(7, 106, 9, -1), Trans(7, 109, 9, -1), - Trans(8, 29, 19, 608), - Trans(8, 30, 19, 608), - Trans(8, 35, 19, 608), - Trans(8, 38, 19, 608), - Trans(8, 42, 19, 608), - Trans(8, 47, 19, 608), - Trans(8, 48, 19, 608), - Trans(8, 49, 19, 608), - Trans(8, 59, 19, 608), - Trans(8, 60, 19, 608), - Trans(8, 63, 19, 608), - Trans(8, 64, 19, 608), - Trans(8, 65, 19, 608), - Trans(8, 69, 19, 608), - Trans(8, 70, 19, 608), - Trans(8, 72, 19, 608), - Trans(8, 76, 19, 608), - Trans(8, 79, 19, 608), - Trans(8, 80, 19, 608), - Trans(8, 83, 19, 608), - Trans(8, 103, 19, 608), - Trans(8, 105, 19, 608), - Trans(8, 108, 19, 608), - Trans(8, 109, 19, 608), - Trans(9, 5, 19, 608), - Trans(9, 111, 19, 608), - Trans(10, 5, 19, 608), - Trans(10, 35, 19, 608), - Trans(10, 38, 19, 608), - Trans(10, 42, 19, 608), - Trans(10, 111, 19, 608), - Trans(11, 5, 19, 608), - Trans(11, 39, 19, 608), - Trans(12, 5, 19, 608), - Trans(12, 29, 19, 608), - Trans(12, 35, 19, 608), - Trans(12, 38, 19, 608), - Trans(12, 42, 19, 608), - Trans(12, 47, 19, 608), - Trans(12, 48, 19, 608), - Trans(12, 49, 19, 608), - Trans(12, 59, 19, 608), - Trans(12, 60, 19, 608), - Trans(12, 63, 19, 608), - Trans(12, 64, 19, 608), - Trans(12, 65, 19, 608), - Trans(12, 69, 19, 608), - Trans(12, 70, 19, 608), - Trans(12, 72, 19, 608), - Trans(12, 76, 19, 608), - Trans(12, 79, 19, 608), - Trans(12, 80, 19, 608), - Trans(12, 83, 19, 608), - Trans(12, 103, 19, 608), - Trans(12, 105, 19, 608), - Trans(12, 108, 19, 608), - Trans(12, 109, 19, 608), - Trans(13, 0, 19, 608), - Trans(13, 5, 19, 608), - Trans(13, 29, 19, 608), - Trans(13, 30, 19, 608), - Trans(13, 35, 19, 608), - Trans(13, 38, 19, 608), - Trans(13, 42, 19, 608), - Trans(13, 47, 19, 608), - Trans(13, 48, 19, 608), - Trans(13, 49, 19, 608), - Trans(13, 57, 19, 608), - Trans(13, 58, 19, 608), - Trans(13, 59, 19, 608), - Trans(13, 60, 19, 608), - Trans(13, 63, 19, 608), - Trans(13, 64, 19, 608), - Trans(13, 65, 19, 608), - Trans(13, 69, 19, 608), - Trans(13, 70, 19, 608), - Trans(13, 71, 19, 608), - Trans(13, 72, 19, 608), - Trans(13, 76, 19, 608), - Trans(13, 77, 19, 608), - Trans(13, 79, 19, 608), - Trans(13, 80, 19, 608), - Trans(13, 83, 19, 608), - Trans(13, 84, 19, 608), - Trans(13, 88, 19, 608), - Trans(13, 90, 19, 608), - Trans(13, 103, 19, 608), - Trans(13, 105, 19, 608), - Trans(13, 108, 19, 608), - Trans(13, 109, 19, 608), - Trans(14, 5, 19, 608), - Trans(14, 38, 19, 608), - Trans(15, 5, 19, 608), - Trans(15, 40, 19, 608), - Trans(16, 5, 19, 608), - Trans(16, 46, 19, 608), - Trans(16, 110, 19, 608), - Trans(16, 111, 19, 608), - Trans(17, 5, 19, 608), - Trans(17, 6, 19, 608), - Trans(17, 7, 19, 608), - Trans(17, 8, 19, 608), - Trans(17, 9, 19, 608), - Trans(17, 10, 19, 608), - Trans(17, 11, 19, 608), - Trans(17, 18, 19, 608), - Trans(17, 24, 19, 608), - Trans(17, 25, 19, 608), - Trans(17, 26, 19, 608), - Trans(17, 27, 19, 608), - Trans(17, 37, 19, 608), - Trans(17, 38, 19, 608), - Trans(17, 40, 19, 608), - Trans(17, 52, 19, 608), - Trans(17, 69, 19, 608), - Trans(17, 75, 19, 608), - Trans(17, 82, 19, 608), - Trans(17, 85, 19, 608), - Trans(17, 87, 19, 608), - Trans(17, 110, 19, 608), - Trans(17, 111, 19, 608), - Trans(18, 5, 19, 608), - Trans(18, 110, 19, 608), - Trans(18, 111, 19, 608), - Trans(20, 5, 19, 608), - Trans(20, 29, 19, 608), - Trans(20, 30, 19, 608), - Trans(20, 35, 19, 608), - Trans(20, 38, 19, 608), - Trans(20, 42, 19, 608), - Trans(20, 47, 19, 608), - Trans(20, 48, 19, 608), - Trans(20, 49, 19, 608), - Trans(20, 59, 19, 608), - Trans(20, 60, 19, 608), - Trans(20, 63, 19, 608), - Trans(20, 64, 19, 608), - Trans(20, 65, 19, 608), - Trans(20, 69, 19, 608), - Trans(20, 70, 19, 608), - Trans(20, 72, 19, 608), - Trans(20, 76, 19, 608), - Trans(20, 79, 19, 608), - Trans(20, 80, 19, 608), - Trans(20, 83, 19, 608), - Trans(20, 103, 19, 608), - Trans(20, 105, 19, 608), - Trans(20, 108, 19, 608), - Trans(20, 109, 19, 608), + Trans(7, 110, 9, -1), + Trans(8, 30, 19, 615), + Trans(8, 31, 19, 615), + Trans(8, 36, 19, 615), + Trans(8, 39, 19, 615), + Trans(8, 43, 19, 615), + Trans(8, 48, 19, 615), + Trans(8, 49, 19, 615), + Trans(8, 50, 19, 615), + Trans(8, 60, 19, 615), + Trans(8, 61, 19, 615), + Trans(8, 64, 19, 615), + Trans(8, 65, 19, 615), + Trans(8, 66, 19, 615), + Trans(8, 70, 19, 615), + Trans(8, 71, 19, 615), + Trans(8, 73, 19, 615), + Trans(8, 77, 19, 615), + Trans(8, 80, 19, 615), + Trans(8, 81, 19, 615), + Trans(8, 84, 19, 615), + Trans(8, 104, 19, 615), + Trans(8, 106, 19, 615), + Trans(8, 109, 19, 615), + Trans(8, 110, 19, 615), + Trans(9, 5, 19, 615), + Trans(9, 112, 19, 615), + Trans(10, 5, 19, 615), + Trans(10, 36, 19, 615), + Trans(10, 39, 19, 615), + Trans(10, 43, 19, 615), + Trans(10, 112, 19, 615), + Trans(11, 5, 19, 615), + Trans(11, 40, 19, 615), + Trans(12, 5, 19, 615), + Trans(12, 30, 19, 615), + Trans(12, 36, 19, 615), + Trans(12, 39, 19, 615), + Trans(12, 43, 19, 615), + Trans(12, 48, 19, 615), + Trans(12, 49, 19, 615), + Trans(12, 50, 19, 615), + Trans(12, 60, 19, 615), + Trans(12, 61, 19, 615), + Trans(12, 64, 19, 615), + Trans(12, 65, 19, 615), + Trans(12, 66, 19, 615), + Trans(12, 70, 19, 615), + Trans(12, 71, 19, 615), + Trans(12, 73, 19, 615), + Trans(12, 77, 19, 615), + Trans(12, 80, 19, 615), + Trans(12, 81, 19, 615), + Trans(12, 84, 19, 615), + Trans(12, 104, 19, 615), + Trans(12, 106, 19, 615), + Trans(12, 109, 19, 615), + Trans(12, 110, 19, 615), + Trans(13, 0, 19, 615), + Trans(13, 5, 19, 615), + Trans(13, 30, 19, 615), + Trans(13, 31, 19, 615), + Trans(13, 36, 19, 615), + Trans(13, 39, 19, 615), + Trans(13, 43, 19, 615), + Trans(13, 48, 19, 615), + Trans(13, 49, 19, 615), + Trans(13, 50, 19, 615), + Trans(13, 58, 19, 615), + Trans(13, 59, 19, 615), + Trans(13, 60, 19, 615), + Trans(13, 61, 19, 615), + Trans(13, 64, 19, 615), + Trans(13, 65, 19, 615), + Trans(13, 66, 19, 615), + Trans(13, 70, 19, 615), + Trans(13, 71, 19, 615), + Trans(13, 72, 19, 615), + Trans(13, 73, 19, 615), + Trans(13, 77, 19, 615), + Trans(13, 78, 19, 615), + Trans(13, 80, 19, 615), + Trans(13, 81, 19, 615), + Trans(13, 84, 19, 615), + Trans(13, 85, 19, 615), + Trans(13, 89, 19, 615), + Trans(13, 91, 19, 615), + Trans(13, 104, 19, 615), + Trans(13, 106, 19, 615), + Trans(13, 109, 19, 615), + Trans(13, 110, 19, 615), + Trans(14, 5, 19, 615), + Trans(14, 39, 19, 615), + Trans(15, 5, 19, 615), + Trans(15, 41, 19, 615), + Trans(16, 5, 19, 615), + Trans(16, 47, 19, 615), + Trans(16, 111, 19, 615), + Trans(16, 112, 19, 615), + Trans(17, 5, 19, 615), + Trans(17, 6, 19, 615), + Trans(17, 7, 19, 615), + Trans(17, 8, 19, 615), + Trans(17, 9, 19, 615), + Trans(17, 10, 19, 615), + Trans(17, 11, 19, 615), + Trans(17, 18, 19, 615), + Trans(17, 24, 19, 615), + Trans(17, 25, 19, 615), + Trans(17, 26, 19, 615), + Trans(17, 27, 19, 615), + Trans(17, 38, 19, 615), + Trans(17, 39, 19, 615), + Trans(17, 41, 19, 615), + Trans(17, 53, 19, 615), + Trans(17, 70, 19, 615), + Trans(17, 76, 19, 615), + Trans(17, 83, 19, 615), + Trans(17, 86, 19, 615), + Trans(17, 88, 19, 615), + Trans(17, 111, 19, 615), + Trans(17, 112, 19, 615), + Trans(18, 5, 19, 615), + Trans(18, 111, 19, 615), + Trans(18, 112, 19, 615), + Trans(20, 5, 19, 615), + Trans(20, 30, 19, 615), + Trans(20, 31, 19, 615), + Trans(20, 36, 19, 615), + Trans(20, 39, 19, 615), + Trans(20, 43, 19, 615), + Trans(20, 48, 19, 615), + Trans(20, 49, 19, 615), + Trans(20, 50, 19, 615), + Trans(20, 60, 19, 615), + Trans(20, 61, 19, 615), + Trans(20, 64, 19, 615), + Trans(20, 65, 19, 615), + Trans(20, 66, 19, 615), + Trans(20, 70, 19, 615), + Trans(20, 71, 19, 615), + Trans(20, 73, 19, 615), + Trans(20, 77, 19, 615), + Trans(20, 80, 19, 615), + Trans(20, 81, 19, 615), + Trans(20, 84, 19, 615), + Trans(20, 104, 19, 615), + Trans(20, 106, 19, 615), + Trans(20, 109, 19, 615), + Trans(20, 110, 19, 615), ], k: 3, }, - /* 145 - "EnumListOpt" */ + /* 148 - "EnumListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 609), Trans(0, 42, 2, 610)], + transitions: &[Trans(0, 31, 1, 616), Trans(0, 43, 2, 617)], k: 1, }, - /* 146 - "EnumTerm" */ + /* 149 - "EnumTerm" */ LookaheadDFA { - prod0: 54, + prod0: 55, transitions: &[], k: 0, }, - /* 147 - "EnumToken" */ + /* 150 - "EnumToken" */ LookaheadDFA { - prod0: 165, + prod0: 167, transitions: &[], k: 0, }, - /* 148 - "Equ" */ + /* 151 - "Equ" */ LookaheadDFA { - prod0: 244, + prod0: 247, transitions: &[], k: 0, }, - /* 149 - "EquTerm" */ + /* 152 - "EquTerm" */ LookaheadDFA { - prod0: 29, + prod0: 30, transitions: &[], k: 0, }, - /* 150 - "EquToken" */ + /* 153 - "EquToken" */ LookaheadDFA { - prod0: 137, + prod0: 139, transitions: &[], k: 0, }, - /* 151 - "Exponent" */ + /* 154 - "Exponent" */ LookaheadDFA { - prod0: 220, + prod0: 222, transitions: &[], k: 0, }, - /* 152 - "ExponentTerm" */ + /* 155 - "ExponentTerm" */ LookaheadDFA { prod0: 2, transitions: &[], k: 0, }, - /* 153 - "ExponentToken" */ + /* 156 - "ExponentToken" */ LookaheadDFA { - prod0: 113, + prod0: 114, transitions: &[], k: 0, }, - /* 154 - "Export" */ + /* 157 - "Export" */ LookaheadDFA { - prod0: 274, + prod0: 277, transitions: &[], k: 0, }, - /* 155 - "ExportDeclaration" */ + /* 158 - "ExportDeclaration" */ LookaheadDFA { - prod0: 730, + prod0: 756, transitions: &[], k: 0, }, - /* 156 - "ExportDeclarationGroup" */ + /* 159 - "ExportDeclarationGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 46, 1, 731), - Trans(0, 110, 2, 732), - Trans(0, 111, 2, 732), + Trans(0, 47, 1, 757), + Trans(0, 111, 2, 758), + Trans(0, 112, 2, 758), ], k: 1, }, - /* 157 - "ExportDeclarationOpt" */ + /* 160 - "ExportDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 28, 1, 733), Trans(0, 45, 2, 734)], + transitions: &[Trans(0, 29, 1, 759), Trans(0, 46, 2, 760)], k: 1, }, - /* 158 - "ExportTerm" */ + /* 161 - "ExportTerm" */ LookaheadDFA { - prod0: 55, + prod0: 56, transitions: &[], k: 0, }, - /* 159 - "ExportToken" */ + /* 162 - "ExportToken" */ LookaheadDFA { - prod0: 166, + prod0: 168, transitions: &[], k: 0, }, - /* 160 - "Expression" */ + /* 163 - "Expression" */ LookaheadDFA { - prod0: 351, + prod0: 358, transitions: &[], k: 0, }, - /* 161 - "Expression01" */ + /* 164 - "Expression01" */ LookaheadDFA { - prod0: 354, + prod0: 361, transitions: &[], k: 0, }, - /* 162 - "Expression01List" */ + /* 165 - "Expression01List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 356), - Trans(0, 14, 2, 356), - Trans(0, 22, 1, 355), - Trans(0, 23, 2, 356), - Trans(0, 29, 2, 356), - Trans(0, 30, 2, 356), - Trans(0, 31, 2, 356), - Trans(0, 32, 2, 356), - Trans(0, 38, 2, 356), - Trans(0, 41, 2, 356), - Trans(0, 42, 2, 356), - Trans(0, 43, 2, 356), - Trans(0, 44, 2, 356), - Trans(0, 45, 2, 356), - Trans(0, 92, 2, 356), - Trans(0, 101, 2, 356), + Trans(0, 12, 2, 363), + Trans(0, 14, 2, 363), + Trans(0, 22, 1, 362), + Trans(0, 23, 2, 363), + Trans(0, 30, 2, 363), + Trans(0, 31, 2, 363), + Trans(0, 32, 2, 363), + Trans(0, 33, 2, 363), + Trans(0, 39, 2, 363), + Trans(0, 42, 2, 363), + Trans(0, 43, 2, 363), + Trans(0, 44, 2, 363), + Trans(0, 45, 2, 363), + Trans(0, 46, 2, 363), + Trans(0, 93, 2, 363), + Trans(0, 102, 2, 363), ], k: 1, }, - /* 163 - "Expression02" */ + /* 166 - "Expression02" */ LookaheadDFA { - prod0: 357, + prod0: 364, transitions: &[], k: 0, }, - /* 164 - "Expression02List" */ + /* 167 - "Expression02List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 359), - Trans(0, 14, 2, 359), - Trans(0, 22, 2, 359), - Trans(0, 23, 2, 359), - Trans(0, 26, 1, 358), - Trans(0, 29, 2, 359), - Trans(0, 30, 2, 359), - Trans(0, 31, 2, 359), - Trans(0, 32, 2, 359), - Trans(0, 38, 2, 359), - Trans(0, 41, 2, 359), - Trans(0, 42, 2, 359), - Trans(0, 43, 2, 359), - Trans(0, 44, 2, 359), - Trans(0, 45, 2, 359), - Trans(0, 92, 2, 359), - Trans(0, 101, 2, 359), + Trans(0, 12, 2, 366), + Trans(0, 14, 2, 366), + Trans(0, 22, 2, 366), + Trans(0, 23, 2, 366), + Trans(0, 26, 1, 365), + Trans(0, 30, 2, 366), + Trans(0, 31, 2, 366), + Trans(0, 32, 2, 366), + Trans(0, 33, 2, 366), + Trans(0, 39, 2, 366), + Trans(0, 42, 2, 366), + Trans(0, 43, 2, 366), + Trans(0, 44, 2, 366), + Trans(0, 45, 2, 366), + Trans(0, 46, 2, 366), + Trans(0, 93, 2, 366), + Trans(0, 102, 2, 366), ], k: 1, }, - /* 165 - "Expression03" */ + /* 168 - "Expression03" */ LookaheadDFA { - prod0: 360, + prod0: 367, transitions: &[], k: 0, }, - /* 166 - "Expression03List" */ + /* 169 - "Expression03List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 362), - Trans(0, 14, 2, 362), - Trans(0, 22, 2, 362), - Trans(0, 23, 2, 362), - Trans(0, 25, 1, 361), - Trans(0, 26, 2, 362), - Trans(0, 29, 2, 362), - Trans(0, 30, 2, 362), - Trans(0, 31, 2, 362), - Trans(0, 32, 2, 362), - Trans(0, 38, 2, 362), - Trans(0, 41, 2, 362), - Trans(0, 42, 2, 362), - Trans(0, 43, 2, 362), - Trans(0, 44, 2, 362), - Trans(0, 45, 2, 362), - Trans(0, 92, 2, 362), - Trans(0, 101, 2, 362), + Trans(0, 12, 2, 369), + Trans(0, 14, 2, 369), + Trans(0, 22, 2, 369), + Trans(0, 23, 2, 369), + Trans(0, 25, 1, 368), + Trans(0, 26, 2, 369), + Trans(0, 30, 2, 369), + Trans(0, 31, 2, 369), + Trans(0, 32, 2, 369), + Trans(0, 33, 2, 369), + Trans(0, 39, 2, 369), + Trans(0, 42, 2, 369), + Trans(0, 43, 2, 369), + Trans(0, 44, 2, 369), + Trans(0, 45, 2, 369), + Trans(0, 46, 2, 369), + Trans(0, 93, 2, 369), + Trans(0, 102, 2, 369), ], k: 1, }, - /* 167 - "Expression04" */ + /* 170 - "Expression04" */ LookaheadDFA { - prod0: 363, + prod0: 370, transitions: &[], k: 0, }, - /* 168 - "Expression04List" */ + /* 171 - "Expression04List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 365), - Trans(0, 14, 2, 365), - Trans(0, 22, 2, 365), - Trans(0, 23, 2, 365), - Trans(0, 24, 1, 364), - Trans(0, 25, 2, 365), - Trans(0, 26, 2, 365), - Trans(0, 29, 2, 365), - Trans(0, 30, 2, 365), - Trans(0, 31, 2, 365), - Trans(0, 32, 2, 365), - Trans(0, 38, 2, 365), - Trans(0, 41, 2, 365), - Trans(0, 42, 2, 365), - Trans(0, 43, 2, 365), - Trans(0, 44, 2, 365), - Trans(0, 45, 2, 365), - Trans(0, 92, 2, 365), - Trans(0, 101, 2, 365), + Trans(0, 12, 2, 372), + Trans(0, 14, 2, 372), + Trans(0, 22, 2, 372), + Trans(0, 23, 2, 372), + Trans(0, 24, 1, 371), + Trans(0, 25, 2, 372), + Trans(0, 26, 2, 372), + Trans(0, 30, 2, 372), + Trans(0, 31, 2, 372), + Trans(0, 32, 2, 372), + Trans(0, 33, 2, 372), + Trans(0, 39, 2, 372), + Trans(0, 42, 2, 372), + Trans(0, 43, 2, 372), + Trans(0, 44, 2, 372), + Trans(0, 45, 2, 372), + Trans(0, 46, 2, 372), + Trans(0, 93, 2, 372), + Trans(0, 102, 2, 372), ], k: 1, }, - /* 169 - "Expression05" */ + /* 172 - "Expression05" */ LookaheadDFA { - prod0: 366, + prod0: 373, transitions: &[], k: 0, }, - /* 170 - "Expression05List" */ + /* 173 - "Expression05List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 368), - Trans(0, 14, 2, 368), - Trans(0, 21, 1, 367), - Trans(0, 22, 2, 368), - Trans(0, 23, 2, 368), - Trans(0, 24, 2, 368), - Trans(0, 25, 2, 368), - Trans(0, 26, 2, 368), - Trans(0, 29, 2, 368), - Trans(0, 30, 2, 368), - Trans(0, 31, 2, 368), - Trans(0, 32, 2, 368), - Trans(0, 38, 2, 368), - Trans(0, 41, 2, 368), - Trans(0, 42, 2, 368), - Trans(0, 43, 2, 368), - Trans(0, 44, 2, 368), - Trans(0, 45, 2, 368), - Trans(0, 92, 2, 368), - Trans(0, 101, 2, 368), + Trans(0, 12, 2, 375), + Trans(0, 14, 2, 375), + Trans(0, 21, 1, 374), + Trans(0, 22, 2, 375), + Trans(0, 23, 2, 375), + Trans(0, 24, 2, 375), + Trans(0, 25, 2, 375), + Trans(0, 26, 2, 375), + Trans(0, 30, 2, 375), + Trans(0, 31, 2, 375), + Trans(0, 32, 2, 375), + Trans(0, 33, 2, 375), + Trans(0, 39, 2, 375), + Trans(0, 42, 2, 375), + Trans(0, 43, 2, 375), + Trans(0, 44, 2, 375), + Trans(0, 45, 2, 375), + Trans(0, 46, 2, 375), + Trans(0, 93, 2, 375), + Trans(0, 102, 2, 375), ], k: 1, }, - /* 171 - "Expression06" */ + /* 174 - "Expression06" */ LookaheadDFA { - prod0: 369, + prod0: 376, transitions: &[], k: 0, }, - /* 172 - "Expression06List" */ + /* 175 - "Expression06List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 371), - Trans(0, 14, 2, 371), - Trans(0, 20, 1, 370), - Trans(0, 21, 2, 371), - Trans(0, 22, 2, 371), - Trans(0, 23, 2, 371), - Trans(0, 24, 2, 371), - Trans(0, 25, 2, 371), - Trans(0, 26, 2, 371), - Trans(0, 29, 2, 371), - Trans(0, 30, 2, 371), - Trans(0, 31, 2, 371), - Trans(0, 32, 2, 371), - Trans(0, 38, 2, 371), - Trans(0, 41, 2, 371), - Trans(0, 42, 2, 371), - Trans(0, 43, 2, 371), - Trans(0, 44, 2, 371), - Trans(0, 45, 2, 371), - Trans(0, 92, 2, 371), - Trans(0, 101, 2, 371), + Trans(0, 12, 2, 378), + Trans(0, 14, 2, 378), + Trans(0, 20, 1, 377), + Trans(0, 21, 2, 378), + Trans(0, 22, 2, 378), + Trans(0, 23, 2, 378), + Trans(0, 24, 2, 378), + Trans(0, 25, 2, 378), + Trans(0, 26, 2, 378), + Trans(0, 30, 2, 378), + Trans(0, 31, 2, 378), + Trans(0, 32, 2, 378), + Trans(0, 33, 2, 378), + Trans(0, 39, 2, 378), + Trans(0, 42, 2, 378), + Trans(0, 43, 2, 378), + Trans(0, 44, 2, 378), + Trans(0, 45, 2, 378), + Trans(0, 46, 2, 378), + Trans(0, 93, 2, 378), + Trans(0, 102, 2, 378), ], k: 1, }, - /* 173 - "Expression07" */ + /* 176 - "Expression07" */ LookaheadDFA { - prod0: 372, + prod0: 379, transitions: &[], k: 0, }, - /* 174 - "Expression07List" */ + /* 177 - "Expression07List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 374), - Trans(0, 14, 2, 374), - Trans(0, 19, 1, 373), - Trans(0, 20, 2, 374), - Trans(0, 21, 2, 374), - Trans(0, 22, 2, 374), - Trans(0, 23, 2, 374), - Trans(0, 24, 2, 374), - Trans(0, 25, 2, 374), - Trans(0, 26, 2, 374), - Trans(0, 29, 2, 374), - Trans(0, 30, 2, 374), - Trans(0, 31, 2, 374), - Trans(0, 32, 2, 374), - Trans(0, 38, 2, 374), - Trans(0, 41, 2, 374), - Trans(0, 42, 2, 374), - Trans(0, 43, 2, 374), - Trans(0, 44, 2, 374), - Trans(0, 45, 2, 374), - Trans(0, 92, 2, 374), - Trans(0, 101, 2, 374), + Trans(0, 12, 2, 381), + Trans(0, 14, 2, 381), + Trans(0, 19, 1, 380), + Trans(0, 20, 2, 381), + Trans(0, 21, 2, 381), + Trans(0, 22, 2, 381), + Trans(0, 23, 2, 381), + Trans(0, 24, 2, 381), + Trans(0, 25, 2, 381), + Trans(0, 26, 2, 381), + Trans(0, 30, 2, 381), + Trans(0, 31, 2, 381), + Trans(0, 32, 2, 381), + Trans(0, 33, 2, 381), + Trans(0, 39, 2, 381), + Trans(0, 42, 2, 381), + Trans(0, 43, 2, 381), + Trans(0, 44, 2, 381), + Trans(0, 45, 2, 381), + Trans(0, 46, 2, 381), + Trans(0, 93, 2, 381), + Trans(0, 102, 2, 381), ], k: 1, }, - /* 175 - "Expression08" */ + /* 178 - "Expression08" */ LookaheadDFA { - prod0: 375, + prod0: 382, transitions: &[], k: 0, }, - /* 176 - "Expression08List" */ + /* 179 - "Expression08List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 377), - Trans(0, 14, 2, 377), - Trans(0, 18, 1, 376), - Trans(0, 19, 2, 377), - Trans(0, 20, 2, 377), - Trans(0, 21, 2, 377), - Trans(0, 22, 2, 377), - Trans(0, 23, 2, 377), - Trans(0, 24, 2, 377), - Trans(0, 25, 2, 377), - Trans(0, 26, 2, 377), - Trans(0, 29, 2, 377), - Trans(0, 30, 2, 377), - Trans(0, 31, 2, 377), - Trans(0, 32, 2, 377), - Trans(0, 38, 2, 377), - Trans(0, 41, 2, 377), - Trans(0, 42, 2, 377), - Trans(0, 43, 2, 377), - Trans(0, 44, 2, 377), - Trans(0, 45, 2, 377), - Trans(0, 92, 2, 377), - Trans(0, 101, 2, 377), + Trans(0, 12, 2, 384), + Trans(0, 14, 2, 384), + Trans(0, 18, 1, 383), + Trans(0, 19, 2, 384), + Trans(0, 20, 2, 384), + Trans(0, 21, 2, 384), + Trans(0, 22, 2, 384), + Trans(0, 23, 2, 384), + Trans(0, 24, 2, 384), + Trans(0, 25, 2, 384), + Trans(0, 26, 2, 384), + Trans(0, 30, 2, 384), + Trans(0, 31, 2, 384), + Trans(0, 32, 2, 384), + Trans(0, 33, 2, 384), + Trans(0, 39, 2, 384), + Trans(0, 42, 2, 384), + Trans(0, 43, 2, 384), + Trans(0, 44, 2, 384), + Trans(0, 45, 2, 384), + Trans(0, 46, 2, 384), + Trans(0, 93, 2, 384), + Trans(0, 102, 2, 384), ], k: 1, }, - /* 177 - "Expression09" */ + /* 180 - "Expression09" */ LookaheadDFA { - prod0: 378, + prod0: 385, transitions: &[], k: 0, }, - /* 178 - "Expression09List" */ + /* 181 - "Expression09List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 382), - Trans(0, 14, 2, 382), - Trans(0, 17, 1, 379), - Trans(0, 18, 2, 382), - Trans(0, 19, 2, 382), - Trans(0, 20, 2, 382), - Trans(0, 21, 2, 382), - Trans(0, 22, 2, 382), - Trans(0, 23, 2, 382), - Trans(0, 24, 2, 382), - Trans(0, 25, 2, 382), - Trans(0, 26, 2, 382), - Trans(0, 29, 2, 382), - Trans(0, 30, 2, 382), - Trans(0, 31, 2, 382), - Trans(0, 32, 2, 382), - Trans(0, 38, 2, 382), - Trans(0, 41, 2, 382), - Trans(0, 42, 2, 382), - Trans(0, 43, 2, 382), - Trans(0, 44, 2, 382), - Trans(0, 45, 2, 382), - Trans(0, 46, 1, 379), - Trans(0, 92, 2, 382), - Trans(0, 101, 2, 382), + Trans(0, 12, 2, 389), + Trans(0, 14, 2, 389), + Trans(0, 17, 1, 386), + Trans(0, 18, 2, 389), + Trans(0, 19, 2, 389), + Trans(0, 20, 2, 389), + Trans(0, 21, 2, 389), + Trans(0, 22, 2, 389), + Trans(0, 23, 2, 389), + Trans(0, 24, 2, 389), + Trans(0, 25, 2, 389), + Trans(0, 26, 2, 389), + Trans(0, 30, 2, 389), + Trans(0, 31, 2, 389), + Trans(0, 32, 2, 389), + Trans(0, 33, 2, 389), + Trans(0, 39, 2, 389), + Trans(0, 42, 2, 389), + Trans(0, 43, 2, 389), + Trans(0, 44, 2, 389), + Trans(0, 45, 2, 389), + Trans(0, 46, 2, 389), + Trans(0, 47, 1, 386), + Trans(0, 93, 2, 389), + Trans(0, 102, 2, 389), ], k: 1, }, - /* 179 - "Expression09ListGroup" */ + /* 182 - "Expression09ListGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 17, 1, 380), Trans(0, 46, 2, 381)], + transitions: &[Trans(0, 17, 1, 387), Trans(0, 47, 2, 388)], k: 1, }, - /* 180 - "Expression10" */ + /* 183 - "Expression10" */ LookaheadDFA { - prod0: 383, + prod0: 390, transitions: &[], k: 0, }, - /* 181 - "Expression10List" */ + /* 184 - "Expression10List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 385), - Trans(0, 14, 2, 385), - Trans(0, 16, 1, 384), - Trans(0, 17, 2, 385), - Trans(0, 18, 2, 385), - Trans(0, 19, 2, 385), - Trans(0, 20, 2, 385), - Trans(0, 21, 2, 385), - Trans(0, 22, 2, 385), - Trans(0, 23, 2, 385), - Trans(0, 24, 2, 385), - Trans(0, 25, 2, 385), - Trans(0, 26, 2, 385), - Trans(0, 29, 2, 385), - Trans(0, 30, 2, 385), - Trans(0, 31, 2, 385), - Trans(0, 32, 2, 385), - Trans(0, 38, 2, 385), - Trans(0, 41, 2, 385), - Trans(0, 42, 2, 385), - Trans(0, 43, 2, 385), - Trans(0, 44, 2, 385), - Trans(0, 45, 2, 385), - Trans(0, 46, 2, 385), - Trans(0, 92, 2, 385), - Trans(0, 101, 2, 385), + Trans(0, 12, 2, 392), + Trans(0, 14, 2, 392), + Trans(0, 16, 1, 391), + Trans(0, 17, 2, 392), + Trans(0, 18, 2, 392), + Trans(0, 19, 2, 392), + Trans(0, 20, 2, 392), + Trans(0, 21, 2, 392), + Trans(0, 22, 2, 392), + Trans(0, 23, 2, 392), + Trans(0, 24, 2, 392), + Trans(0, 25, 2, 392), + Trans(0, 26, 2, 392), + Trans(0, 30, 2, 392), + Trans(0, 31, 2, 392), + Trans(0, 32, 2, 392), + Trans(0, 33, 2, 392), + Trans(0, 39, 2, 392), + Trans(0, 42, 2, 392), + Trans(0, 43, 2, 392), + Trans(0, 44, 2, 392), + Trans(0, 45, 2, 392), + Trans(0, 46, 2, 392), + Trans(0, 47, 2, 392), + Trans(0, 93, 2, 392), + Trans(0, 102, 2, 392), ], k: 1, }, - /* 182 - "Expression11" */ + /* 185 - "Expression11" */ LookaheadDFA { - prod0: 386, + prod0: 393, transitions: &[], k: 0, }, - /* 183 - "Expression11List" */ + /* 186 - "Expression11List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 388), - Trans(0, 14, 2, 388), - Trans(0, 16, 2, 388), - Trans(0, 17, 2, 388), - Trans(0, 18, 2, 388), - Trans(0, 19, 2, 388), - Trans(0, 20, 2, 388), - Trans(0, 21, 2, 388), - Trans(0, 22, 2, 388), - Trans(0, 23, 2, 388), - Trans(0, 24, 2, 388), - Trans(0, 25, 2, 388), - Trans(0, 26, 2, 388), - Trans(0, 29, 2, 388), - Trans(0, 30, 2, 388), - Trans(0, 31, 2, 388), - Trans(0, 32, 2, 388), - Trans(0, 38, 2, 388), - Trans(0, 41, 2, 388), - Trans(0, 42, 2, 388), - Trans(0, 43, 2, 388), - Trans(0, 44, 2, 388), - Trans(0, 45, 2, 388), - Trans(0, 46, 2, 388), - Trans(0, 50, 1, 387), - Trans(0, 92, 2, 388), - Trans(0, 101, 2, 388), + Trans(0, 12, 2, 395), + Trans(0, 14, 2, 395), + Trans(0, 16, 2, 395), + Trans(0, 17, 2, 395), + Trans(0, 18, 2, 395), + Trans(0, 19, 2, 395), + Trans(0, 20, 2, 395), + Trans(0, 21, 2, 395), + Trans(0, 22, 2, 395), + Trans(0, 23, 2, 395), + Trans(0, 24, 2, 395), + Trans(0, 25, 2, 395), + Trans(0, 26, 2, 395), + Trans(0, 30, 2, 395), + Trans(0, 31, 2, 395), + Trans(0, 32, 2, 395), + Trans(0, 33, 2, 395), + Trans(0, 39, 2, 395), + Trans(0, 42, 2, 395), + Trans(0, 43, 2, 395), + Trans(0, 44, 2, 395), + Trans(0, 45, 2, 395), + Trans(0, 46, 2, 395), + Trans(0, 47, 2, 395), + Trans(0, 51, 1, 394), + Trans(0, 93, 2, 395), + Trans(0, 102, 2, 395), ], k: 1, }, - /* 184 - "Expression12" */ + /* 187 - "Expression12" */ LookaheadDFA { - prod0: 389, + prod0: 396, transitions: &[], k: 0, }, - /* 185 - "Expression12List" */ + /* 188 - "Expression12List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 2, 396), - Trans(0, 7, 2, 396), - Trans(0, 8, 2, 396), - Trans(0, 9, 2, 396), - Trans(0, 10, 2, 396), - Trans(0, 11, 2, 396), - Trans(0, 18, 1, 390), - Trans(0, 24, 1, 390), - Trans(0, 25, 1, 390), - Trans(0, 26, 1, 390), - Trans(0, 27, 1, 390), - Trans(0, 37, 2, 396), - Trans(0, 38, 2, 396), - Trans(0, 40, 2, 396), - Trans(0, 52, 2, 396), - Trans(0, 69, 2, 396), - Trans(0, 75, 2, 396), - Trans(0, 82, 2, 396), - Trans(0, 85, 2, 396), - Trans(0, 87, 2, 396), - Trans(0, 110, 2, 396), - Trans(0, 111, 2, 396), + Trans(0, 6, 2, 403), + Trans(0, 7, 2, 403), + Trans(0, 8, 2, 403), + Trans(0, 9, 2, 403), + Trans(0, 10, 2, 403), + Trans(0, 11, 2, 403), + Trans(0, 18, 1, 397), + Trans(0, 24, 1, 397), + Trans(0, 25, 1, 397), + Trans(0, 26, 1, 397), + Trans(0, 27, 1, 397), + Trans(0, 38, 2, 403), + Trans(0, 39, 2, 403), + Trans(0, 41, 2, 403), + Trans(0, 53, 2, 403), + Trans(0, 70, 2, 403), + Trans(0, 76, 2, 403), + Trans(0, 83, 2, 403), + Trans(0, 86, 2, 403), + Trans(0, 88, 2, 403), + Trans(0, 111, 2, 403), + Trans(0, 112, 2, 403), ], k: 1, }, - /* 186 - "Expression12ListGroup" */ + /* 189 - "Expression12ListGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 18, 2, 392), - Trans(0, 24, 3, 393), - Trans(0, 25, 5, 395), - Trans(0, 26, 4, 394), - Trans(0, 27, 1, 391), + Trans(0, 18, 2, 399), + Trans(0, 24, 3, 400), + Trans(0, 25, 5, 402), + Trans(0, 26, 4, 401), + Trans(0, 27, 1, 398), ], k: 1, }, - /* 187 - "ExpressionIdentifier" */ + /* 190 - "ExpressionIdentifier" */ LookaheadDFA { - prod0: 344, + prod0: 351, transitions: &[], k: 0, }, - /* 188 - "ExpressionIdentifierList" */ + /* 191 - "ExpressionIdentifierList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 350), - Trans(0, 14, 2, 350), - Trans(0, 15, 2, 350), - Trans(0, 16, 2, 350), - Trans(0, 17, 2, 350), - Trans(0, 18, 2, 350), - Trans(0, 19, 2, 350), - Trans(0, 20, 2, 350), - Trans(0, 21, 2, 350), - Trans(0, 22, 2, 350), - Trans(0, 23, 2, 350), - Trans(0, 24, 2, 350), - Trans(0, 25, 2, 350), - Trans(0, 26, 2, 350), - Trans(0, 29, 2, 350), - Trans(0, 30, 2, 350), - Trans(0, 31, 2, 350), - Trans(0, 32, 2, 350), - Trans(0, 33, 2, 350), - Trans(0, 34, 2, 350), - Trans(0, 38, 2, 350), - Trans(0, 39, 1, 349), - Trans(0, 40, 2, 350), - Trans(0, 41, 2, 350), - Trans(0, 42, 2, 350), - Trans(0, 43, 2, 350), - Trans(0, 44, 2, 350), - Trans(0, 45, 2, 350), - Trans(0, 46, 2, 350), - Trans(0, 50, 2, 350), - Trans(0, 92, 2, 350), - Trans(0, 101, 2, 350), + Trans(0, 12, 2, 357), + Trans(0, 14, 2, 357), + Trans(0, 15, 2, 357), + Trans(0, 16, 2, 357), + Trans(0, 17, 2, 357), + Trans(0, 18, 2, 357), + Trans(0, 19, 2, 357), + Trans(0, 20, 2, 357), + Trans(0, 21, 2, 357), + Trans(0, 22, 2, 357), + Trans(0, 23, 2, 357), + Trans(0, 24, 2, 357), + Trans(0, 25, 2, 357), + Trans(0, 26, 2, 357), + Trans(0, 30, 2, 357), + Trans(0, 31, 2, 357), + Trans(0, 32, 2, 357), + Trans(0, 33, 2, 357), + Trans(0, 34, 2, 357), + Trans(0, 35, 2, 357), + Trans(0, 39, 2, 357), + Trans(0, 40, 1, 356), + Trans(0, 41, 2, 357), + Trans(0, 42, 2, 357), + Trans(0, 43, 2, 357), + Trans(0, 44, 2, 357), + Trans(0, 45, 2, 357), + Trans(0, 46, 2, 357), + Trans(0, 47, 2, 357), + Trans(0, 51, 2, 357), + Trans(0, 93, 2, 357), + Trans(0, 102, 2, 357), ], k: 1, }, - /* 189 - "ExpressionIdentifierList0" */ + /* 192 - "ExpressionIdentifierList0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 348), - Trans(0, 14, 2, 348), - Trans(0, 15, 2, 348), - Trans(0, 16, 2, 348), - Trans(0, 17, 2, 348), - Trans(0, 18, 2, 348), - Trans(0, 19, 2, 348), - Trans(0, 20, 2, 348), - Trans(0, 21, 2, 348), - Trans(0, 22, 2, 348), - Trans(0, 23, 2, 348), - Trans(0, 24, 2, 348), - Trans(0, 25, 2, 348), - Trans(0, 26, 2, 348), - Trans(0, 29, 2, 348), - Trans(0, 30, 2, 348), - Trans(0, 31, 2, 348), - Trans(0, 32, 2, 348), - Trans(0, 33, 1, 345), - Trans(0, 34, 2, 348), - Trans(0, 38, 2, 348), - Trans(0, 40, 2, 348), - Trans(0, 41, 2, 348), - Trans(0, 42, 2, 348), - Trans(0, 43, 2, 348), - Trans(0, 44, 2, 348), - Trans(0, 45, 2, 348), - Trans(0, 46, 2, 348), - Trans(0, 50, 2, 348), - Trans(0, 92, 2, 348), - Trans(0, 101, 2, 348), + Trans(0, 12, 2, 355), + Trans(0, 14, 2, 355), + Trans(0, 15, 2, 355), + Trans(0, 16, 2, 355), + Trans(0, 17, 2, 355), + Trans(0, 18, 2, 355), + Trans(0, 19, 2, 355), + Trans(0, 20, 2, 355), + Trans(0, 21, 2, 355), + Trans(0, 22, 2, 355), + Trans(0, 23, 2, 355), + Trans(0, 24, 2, 355), + Trans(0, 25, 2, 355), + Trans(0, 26, 2, 355), + Trans(0, 30, 2, 355), + Trans(0, 31, 2, 355), + Trans(0, 32, 2, 355), + Trans(0, 33, 2, 355), + Trans(0, 34, 1, 352), + Trans(0, 35, 2, 355), + Trans(0, 39, 2, 355), + Trans(0, 41, 2, 355), + Trans(0, 42, 2, 355), + Trans(0, 43, 2, 355), + Trans(0, 44, 2, 355), + Trans(0, 45, 2, 355), + Trans(0, 46, 2, 355), + Trans(0, 47, 2, 355), + Trans(0, 51, 2, 355), + Trans(0, 93, 2, 355), + Trans(0, 102, 2, 355), ], k: 1, }, - /* 190 - "ExpressionIdentifierList0List" */ + /* 193 - "ExpressionIdentifierList0List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 347), - Trans(0, 14, 2, 347), - Trans(0, 15, 2, 347), - Trans(0, 16, 2, 347), - Trans(0, 17, 2, 347), - Trans(0, 18, 2, 347), - Trans(0, 19, 2, 347), - Trans(0, 20, 2, 347), - Trans(0, 21, 2, 347), - Trans(0, 22, 2, 347), - Trans(0, 23, 2, 347), - Trans(0, 24, 2, 347), - Trans(0, 25, 2, 347), - Trans(0, 26, 2, 347), - Trans(0, 29, 2, 347), - Trans(0, 30, 2, 347), - Trans(0, 31, 2, 347), - Trans(0, 32, 2, 347), - Trans(0, 33, 2, 347), - Trans(0, 34, 2, 347), - Trans(0, 38, 2, 347), - Trans(0, 39, 1, 346), - Trans(0, 40, 2, 347), - Trans(0, 41, 2, 347), - Trans(0, 42, 2, 347), - Trans(0, 43, 2, 347), - Trans(0, 44, 2, 347), - Trans(0, 45, 2, 347), - Trans(0, 46, 2, 347), - Trans(0, 50, 2, 347), - Trans(0, 92, 2, 347), - Trans(0, 101, 2, 347), + Trans(0, 12, 2, 354), + Trans(0, 14, 2, 354), + Trans(0, 15, 2, 354), + Trans(0, 16, 2, 354), + Trans(0, 17, 2, 354), + Trans(0, 18, 2, 354), + Trans(0, 19, 2, 354), + Trans(0, 20, 2, 354), + Trans(0, 21, 2, 354), + Trans(0, 22, 2, 354), + Trans(0, 23, 2, 354), + Trans(0, 24, 2, 354), + Trans(0, 25, 2, 354), + Trans(0, 26, 2, 354), + Trans(0, 30, 2, 354), + Trans(0, 31, 2, 354), + Trans(0, 32, 2, 354), + Trans(0, 33, 2, 354), + Trans(0, 34, 2, 354), + Trans(0, 35, 2, 354), + Trans(0, 39, 2, 354), + Trans(0, 40, 1, 353), + Trans(0, 41, 2, 354), + Trans(0, 42, 2, 354), + Trans(0, 43, 2, 354), + Trans(0, 44, 2, 354), + Trans(0, 45, 2, 354), + Trans(0, 46, 2, 354), + Trans(0, 47, 2, 354), + Trans(0, 51, 2, 354), + Trans(0, 93, 2, 354), + Trans(0, 102, 2, 354), ], k: 1, }, - /* 191 - "ExpressionList" */ + /* 194 - "ExpressionList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 353), - Trans(0, 14, 2, 353), - Trans(0, 23, 1, 352), - Trans(0, 29, 2, 353), - Trans(0, 30, 2, 353), - Trans(0, 31, 2, 353), - Trans(0, 32, 2, 353), - Trans(0, 38, 2, 353), - Trans(0, 41, 2, 353), - Trans(0, 42, 2, 353), - Trans(0, 43, 2, 353), - Trans(0, 44, 2, 353), - Trans(0, 45, 2, 353), - Trans(0, 92, 2, 353), - Trans(0, 101, 2, 353), + Trans(0, 12, 2, 360), + Trans(0, 14, 2, 360), + Trans(0, 23, 1, 359), + Trans(0, 30, 2, 360), + Trans(0, 31, 2, 360), + Trans(0, 32, 2, 360), + Trans(0, 33, 2, 360), + Trans(0, 39, 2, 360), + Trans(0, 42, 2, 360), + Trans(0, 43, 2, 360), + Trans(0, 44, 2, 360), + Trans(0, 45, 2, 360), + Trans(0, 46, 2, 360), + Trans(0, 93, 2, 360), + Trans(0, 102, 2, 360), ], k: 1, }, - /* 192 - "F32" */ + /* 195 - "F32" */ LookaheadDFA { - prod0: 275, + prod0: 278, transitions: &[], k: 0, }, - /* 193 - "F32Term" */ + /* 196 - "F32Term" */ LookaheadDFA { - prod0: 56, + prod0: 57, transitions: &[], k: 0, }, - /* 194 - "F32Token" */ + /* 197 - "F32Token" */ LookaheadDFA { - prod0: 167, + prod0: 169, transitions: &[], k: 0, }, - /* 195 - "F64" */ + /* 198 - "F64" */ LookaheadDFA { - prod0: 276, + prod0: 279, transitions: &[], k: 0, }, - /* 196 - "F64Term" */ + /* 199 - "F64Term" */ LookaheadDFA { - prod0: 57, + prod0: 58, transitions: &[], k: 0, }, - /* 197 - "F64Token" */ + /* 200 - "F64Token" */ LookaheadDFA { - prod0: 168, + prod0: 170, transitions: &[], k: 0, }, - /* 198 - "Factor" */ + /* 201 - "Factor" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 8, 404), - Trans(0, 7, 1, 397), - Trans(0, 8, 1, 397), - Trans(0, 9, 1, 397), - Trans(0, 10, 1, 397), - Trans(0, 11, 1, 397), - Trans(0, 37, 5, 401), - Trans(0, 38, 4, 400), - Trans(0, 40, 3, 399), - Trans(0, 52, 7, 403), - Trans(0, 69, 6, 402), - Trans(0, 75, 10, 408), - Trans(0, 82, 9, 405), - Trans(0, 85, 9, 405), - Trans(0, 87, 11, 409), - Trans(0, 110, 2, 398), - Trans(0, 111, 2, 398), + Trans(0, 6, 8, 411), + Trans(0, 7, 1, 404), + Trans(0, 8, 1, 404), + Trans(0, 9, 1, 404), + Trans(0, 10, 1, 404), + Trans(0, 11, 1, 404), + Trans(0, 38, 5, 408), + Trans(0, 39, 4, 407), + Trans(0, 41, 3, 406), + Trans(0, 53, 7, 410), + Trans(0, 70, 6, 409), + Trans(0, 76, 10, 415), + Trans(0, 83, 9, 412), + Trans(0, 86, 9, 412), + Trans(0, 88, 11, 416), + Trans(0, 111, 2, 405), + Trans(0, 112, 2, 405), ], k: 1, }, - /* 199 - "FactorGroup" */ + /* 202 - "FactorGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 82, 2, 407), Trans(0, 85, 1, 406)], + transitions: &[Trans(0, 83, 2, 414), Trans(0, 86, 1, 413)], k: 1, }, - /* 200 - "FactorOpt" */ + /* 203 - "FactorOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 2, 411), - Trans(0, 14, 2, 411), - Trans(0, 16, 2, 411), - Trans(0, 17, 2, 411), - Trans(0, 18, 2, 411), - Trans(0, 19, 2, 411), - Trans(0, 20, 2, 411), - Trans(0, 21, 2, 411), - Trans(0, 22, 2, 411), - Trans(0, 23, 2, 411), - Trans(0, 24, 2, 411), - Trans(0, 25, 2, 411), - Trans(0, 26, 2, 411), - Trans(0, 29, 2, 411), - Trans(0, 30, 2, 411), - Trans(0, 31, 2, 411), - Trans(0, 32, 2, 411), - Trans(0, 38, 2, 411), - Trans(0, 40, 1, 410), - Trans(0, 41, 2, 411), - Trans(0, 42, 2, 411), - Trans(0, 43, 2, 411), - Trans(0, 44, 2, 411), - Trans(0, 45, 2, 411), - Trans(0, 46, 2, 411), - Trans(0, 50, 2, 411), - Trans(0, 92, 2, 411), - Trans(0, 101, 2, 411), + Trans(0, 12, 2, 418), + Trans(0, 14, 2, 418), + Trans(0, 16, 2, 418), + Trans(0, 17, 2, 418), + Trans(0, 18, 2, 418), + Trans(0, 19, 2, 418), + Trans(0, 20, 2, 418), + Trans(0, 21, 2, 418), + Trans(0, 22, 2, 418), + Trans(0, 23, 2, 418), + Trans(0, 24, 2, 418), + Trans(0, 25, 2, 418), + Trans(0, 26, 2, 418), + Trans(0, 30, 2, 418), + Trans(0, 31, 2, 418), + Trans(0, 32, 2, 418), + Trans(0, 33, 2, 418), + Trans(0, 39, 2, 418), + Trans(0, 41, 1, 417), + Trans(0, 42, 2, 418), + Trans(0, 43, 2, 418), + Trans(0, 44, 2, 418), + Trans(0, 45, 2, 418), + Trans(0, 46, 2, 418), + Trans(0, 47, 2, 418), + Trans(0, 51, 2, 418), + Trans(0, 93, 2, 418), + Trans(0, 102, 2, 418), ], k: 1, }, - /* 201 - "Final" */ + /* 204 - "Final" */ LookaheadDFA { - prod0: 277, + prod0: 280, transitions: &[], k: 0, }, - /* 202 - "FinalDeclaration" */ + /* 205 - "FinalDeclaration" */ LookaheadDFA { - prod0: 636, + prod0: 645, transitions: &[], k: 0, }, - /* 203 - "FinalDeclarationList" */ + /* 206 - "FinalDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 638), - Trans(0, 52, 1, 637), - Trans(0, 64, 1, 637), - Trans(0, 68, 1, 637), - Trans(0, 69, 1, 637), - Trans(0, 79, 1, 637), - Trans(0, 98, 1, 637), - Trans(0, 99, 1, 637), - Trans(0, 110, 1, 637), - Trans(0, 111, 1, 637), + Trans(0, 43, 2, 647), + Trans(0, 53, 1, 646), + Trans(0, 65, 1, 646), + Trans(0, 69, 1, 646), + Trans(0, 70, 1, 646), + Trans(0, 80, 1, 646), + Trans(0, 99, 1, 646), + Trans(0, 100, 1, 646), + Trans(0, 111, 1, 646), + Trans(0, 112, 1, 646), ], k: 1, }, - /* 204 - "FinalTerm" */ + /* 207 - "FinalTerm" */ LookaheadDFA { - prod0: 58, + prod0: 59, transitions: &[], k: 0, }, - /* 205 - "FinalToken" */ + /* 208 - "FinalToken" */ LookaheadDFA { - prod0: 169, + prod0: 171, transitions: &[], k: 0, }, - /* 206 - "FixedPoint" */ + /* 209 - "FixedPoint" */ LookaheadDFA { - prod0: 221, + prod0: 223, transitions: &[], k: 0, }, - /* 207 - "FixedPointTerm" */ + /* 210 - "FixedPointTerm" */ LookaheadDFA { prod0: 3, transitions: &[], k: 0, }, - /* 208 - "FixedPointToken" */ + /* 211 - "FixedPointToken" */ LookaheadDFA { - prod0: 114, + prod0: 115, transitions: &[], k: 0, }, - /* 209 - "FixedType" */ + /* 212 - "FixedType" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 61, 5, 483), - Trans(0, 62, 6, 484), - Trans(0, 66, 3, 481), - Trans(0, 67, 4, 482), - Trans(0, 102, 7, 485), - Trans(0, 106, 1, 479), - Trans(0, 107, 2, 480), + Trans(0, 62, 5, 490), + Trans(0, 63, 6, 491), + Trans(0, 67, 3, 488), + Trans(0, 68, 4, 489), + Trans(0, 103, 7, 492), + Trans(0, 107, 1, 486), + Trans(0, 108, 2, 487), ], k: 1, }, - /* 210 - "For" */ + /* 213 - "For" */ LookaheadDFA { - prod0: 278, + prod0: 281, transitions: &[], k: 0, }, - /* 211 - "ForStatement" */ + /* 214 - "ForStatement" */ LookaheadDFA { - prod0: 549, + prod0: 556, transitions: &[], k: 0, }, - /* 212 - "ForStatementList" */ + /* 215 - "ForStatementList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 551), - Trans(0, 52, 1, 550), - Trans(0, 64, 1, 550), - Trans(0, 68, 1, 550), - Trans(0, 69, 1, 550), - Trans(0, 79, 1, 550), - Trans(0, 98, 1, 550), - Trans(0, 99, 1, 550), - Trans(0, 110, 1, 550), - Trans(0, 111, 1, 550), + Trans(0, 43, 2, 558), + Trans(0, 53, 1, 557), + Trans(0, 65, 1, 557), + Trans(0, 69, 1, 557), + Trans(0, 70, 1, 557), + Trans(0, 80, 1, 557), + Trans(0, 99, 1, 557), + Trans(0, 100, 1, 557), + Trans(0, 111, 1, 557), + Trans(0, 112, 1, 557), ], k: 1, }, - /* 213 - "ForStatementOpt" */ + /* 216 - "ForStatementOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 38, 2, 553), Trans(0, 101, 1, 552)], + transitions: &[Trans(0, 39, 2, 560), Trans(0, 102, 1, 559)], k: 1, }, - /* 214 - "ForTerm" */ + /* 217 - "ForTerm" */ LookaheadDFA { - prod0: 59, + prod0: 60, transitions: &[], k: 0, }, - /* 215 - "ForToken" */ + /* 218 - "ForToken" */ LookaheadDFA { - prod0: 170, + prod0: 172, transitions: &[], k: 0, }, - /* 216 - "Function" */ + /* 219 - "Function" */ LookaheadDFA { - prod0: 279, + prod0: 282, transitions: &[], k: 0, }, - /* 217 - "FunctionCall" */ + /* 220 - "FunctionCall" */ LookaheadDFA { - prod0: 412, + prod0: 419, transitions: &[], k: 0, }, - /* 218 - "FunctionCallOpt" */ + /* 221 - "FunctionCallOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 1, 413), - Trans(0, 7, 1, 413), - Trans(0, 8, 1, 413), - Trans(0, 9, 1, 413), - Trans(0, 10, 1, 413), - Trans(0, 11, 1, 413), - Trans(0, 18, 1, 413), - Trans(0, 24, 1, 413), - Trans(0, 25, 1, 413), - Trans(0, 26, 1, 413), - Trans(0, 27, 1, 413), - Trans(0, 37, 1, 413), - Trans(0, 38, 1, 413), - Trans(0, 40, 1, 413), - Trans(0, 44, 2, 414), - Trans(0, 52, 1, 413), - Trans(0, 69, 1, 413), - Trans(0, 75, 1, 413), - Trans(0, 82, 1, 413), - Trans(0, 85, 1, 413), - Trans(0, 87, 1, 413), - Trans(0, 110, 1, 413), - Trans(0, 111, 1, 413), + Trans(0, 6, 1, 420), + Trans(0, 7, 1, 420), + Trans(0, 8, 1, 420), + Trans(0, 9, 1, 420), + Trans(0, 10, 1, 420), + Trans(0, 11, 1, 420), + Trans(0, 18, 1, 420), + Trans(0, 24, 1, 420), + Trans(0, 25, 1, 420), + Trans(0, 26, 1, 420), + Trans(0, 27, 1, 420), + Trans(0, 38, 1, 420), + Trans(0, 39, 1, 420), + Trans(0, 41, 1, 420), + Trans(0, 45, 2, 421), + Trans(0, 53, 1, 420), + Trans(0, 70, 1, 420), + Trans(0, 76, 1, 420), + Trans(0, 83, 1, 420), + Trans(0, 86, 1, 420), + Trans(0, 88, 1, 420), + Trans(0, 111, 1, 420), + Trans(0, 112, 1, 420), ], k: 1, }, - /* 219 - "FunctionDeclaration" */ + /* 222 - "FunctionDeclaration" */ LookaheadDFA { - prod0: 718, + prod0: 742, transitions: &[], k: 0, }, - /* 220 - "FunctionDeclarationList" */ + /* 223 - "FunctionDeclarationList" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 43, 2, 744), + Trans(0, 53, 1, 743), + Trans(0, 65, 1, 743), + Trans(0, 69, 1, 743), + Trans(0, 70, 1, 743), + Trans(0, 80, 1, 743), + Trans(0, 99, 1, 743), + Trans(0, 100, 1, 743), + Trans(0, 110, 1, 743), + Trans(0, 111, 1, 743), + Trans(0, 112, 1, 743), + ], + k: 1, + }, + /* 224 - "FunctionDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 720), - Trans(0, 52, 1, 719), - Trans(0, 64, 1, 719), - Trans(0, 68, 1, 719), - Trans(0, 69, 1, 719), - Trans(0, 79, 1, 719), - Trans(0, 98, 1, 719), - Trans(0, 99, 1, 719), - Trans(0, 109, 1, 719), - Trans(0, 110, 1, 719), - Trans(0, 111, 1, 719), + Trans(0, 13, 2, 750), + Trans(0, 28, 1, 749), + Trans(0, 39, 2, 750), + Trans(0, 41, 2, 750), ], k: 1, }, - /* 221 - "FunctionDeclarationOpt" */ + /* 225 - "FunctionDeclarationOpt0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 13, 2, 724), - Trans(0, 38, 2, 724), - Trans(0, 40, 1, 723), + Trans(0, 13, 2, 748), + Trans(0, 39, 2, 748), + Trans(0, 41, 1, 747), ], k: 1, }, - /* 222 - "FunctionDeclarationOpt0" */ + /* 226 - "FunctionDeclarationOpt1" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 13, 1, 721), Trans(0, 38, 2, 722)], + transitions: &[Trans(0, 13, 1, 745), Trans(0, 39, 2, 746)], k: 1, }, - /* 223 - "FunctionItem" */ + /* 227 - "FunctionItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 52, 2, 726), - Trans(0, 64, 2, 726), - Trans(0, 68, 2, 726), - Trans(0, 69, 2, 726), - Trans(0, 79, 2, 726), - Trans(0, 98, 2, 726), - Trans(0, 99, 2, 726), - Trans(0, 109, 1, 725), - Trans(0, 110, 2, 726), - Trans(0, 111, 2, 726), + Trans(0, 53, 2, 752), + Trans(0, 65, 2, 752), + Trans(0, 69, 2, 752), + Trans(0, 70, 2, 752), + Trans(0, 80, 2, 752), + Trans(0, 99, 2, 752), + Trans(0, 100, 2, 752), + Trans(0, 110, 1, 751), + Trans(0, 111, 2, 752), + Trans(0, 112, 2, 752), ], k: 1, }, - /* 224 - "FunctionTerm" */ + /* 228 - "FunctionTerm" */ LookaheadDFA { - prod0: 60, + prod0: 61, transitions: &[], k: 0, }, - /* 225 - "FunctionToken" */ + /* 229 - "FunctionToken" */ LookaheadDFA { - prod0: 171, + prod0: 173, transitions: &[], k: 0, }, - /* 226 - "Hash" */ + /* 230 - "Hash" */ LookaheadDFA { - prod0: 245, + prod0: 248, transitions: &[], k: 0, }, - /* 227 - "HashTerm" */ + /* 231 - "HashTerm" */ LookaheadDFA { - prod0: 30, + prod0: 31, transitions: &[], k: 0, }, - /* 228 - "HashToken" */ + /* 232 - "HashToken" */ LookaheadDFA { - prod0: 138, + prod0: 140, transitions: &[], k: 0, }, - /* 229 - "HierarchicalIdentifier" */ + /* 233 - "HierarchicalIdentifier" */ LookaheadDFA { - prod0: 332, + prod0: 335, transitions: &[], k: 0, }, - /* 230 - "HierarchicalIdentifierList" */ + /* 234 - "HierarchicalIdentifierList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 2, 338), - Trans(0, 33, 2, 338), - Trans(0, 34, 2, 338), - Trans(0, 39, 1, 337), - Trans(0, 44, 2, 338), + Trans(0, 31, 2, 341), + Trans(0, 34, 2, 341), + Trans(0, 35, 2, 341), + Trans(0, 40, 1, 340), + Trans(0, 45, 2, 341), ], k: 1, }, - /* 231 - "HierarchicalIdentifierList0" */ + /* 235 - "HierarchicalIdentifierList0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 2, 336), - Trans(0, 33, 1, 333), - Trans(0, 34, 2, 336), - Trans(0, 44, 2, 336), + Trans(0, 31, 2, 339), + Trans(0, 34, 1, 336), + Trans(0, 35, 2, 339), + Trans(0, 45, 2, 339), ], k: 1, }, - /* 232 - "HierarchicalIdentifierList0List" */ + /* 236 - "HierarchicalIdentifierList0List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 2, 335), - Trans(0, 33, 2, 335), - Trans(0, 34, 2, 335), - Trans(0, 39, 1, 334), - Trans(0, 44, 2, 335), + Trans(0, 31, 2, 338), + Trans(0, 34, 2, 338), + Trans(0, 35, 2, 338), + Trans(0, 40, 1, 337), + Trans(0, 45, 2, 338), ], k: 1, }, - /* 233 - "I32" */ + /* 237 - "I32" */ LookaheadDFA { - prod0: 280, + prod0: 283, transitions: &[], k: 0, }, - /* 234 - "I32Term" */ + /* 238 - "I32Term" */ LookaheadDFA { - prod0: 61, + prod0: 62, transitions: &[], k: 0, }, - /* 235 - "I32Token" */ + /* 239 - "I32Token" */ LookaheadDFA { - prod0: 172, + prod0: 174, transitions: &[], k: 0, }, - /* 236 - "I64" */ + /* 240 - "I64" */ LookaheadDFA { - prod0: 281, + prod0: 284, transitions: &[], k: 0, }, - /* 237 - "I64Term" */ + /* 241 - "I64Term" */ LookaheadDFA { - prod0: 62, + prod0: 63, transitions: &[], k: 0, }, - /* 238 - "I64Token" */ + /* 242 - "I64Token" */ LookaheadDFA { - prod0: 173, + prod0: 175, transitions: &[], k: 0, }, - /* 239 - "Identifier" */ + /* 243 - "Identifier" */ LookaheadDFA { - prod0: 324, + prod0: 327, transitions: &[], k: 0, }, - /* 240 - "IdentifierStatement" */ + /* 244 - "IdentifierStatement" */ LookaheadDFA { - prod0: 519, + prod0: 526, transitions: &[], k: 0, }, - /* 241 - "IdentifierStatementGroup" */ + /* 245 - "IdentifierStatementGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 15, 2, 521), - Trans(0, 34, 2, 521), - Trans(0, 40, 1, 520), + Trans(0, 15, 2, 528), + Trans(0, 35, 2, 528), + Trans(0, 41, 1, 527), ], k: 1, }, - /* 242 - "IdentifierTerm" */ + /* 246 - "IdentifierTerm" */ LookaheadDFA { - prod0: 106, + prod0: 107, transitions: &[], k: 0, }, - /* 243 - "IdentifierToken" */ + /* 247 - "IdentifierToken" */ LookaheadDFA { - prod0: 217, + prod0: 219, transitions: &[], k: 0, }, - /* 244 - "If" */ + /* 248 - "If" */ LookaheadDFA { - prod0: 282, + prod0: 285, transitions: &[], k: 0, }, - /* 245 - "IfExpression" */ + /* 249 - "IfExpression" */ LookaheadDFA { - prod0: 439, + prod0: 446, transitions: &[], k: 0, }, - /* 246 - "IfExpressionList" */ + /* 250 - "IfExpressionList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 57, 1, -1), + Trans(0, 58, 1, -1), Trans(1, 5, 4, -1), - Trans(1, 38, 5, -1), - Trans(1, 69, 2, -1), - Trans(2, 5, 3, 440), - Trans(2, 6, 3, 440), - Trans(2, 7, 3, 440), - Trans(2, 8, 3, 440), - Trans(2, 9, 3, 440), - Trans(2, 10, 3, 440), - Trans(2, 11, 3, 440), - Trans(2, 18, 3, 440), - Trans(2, 24, 3, 440), - Trans(2, 25, 3, 440), - Trans(2, 26, 3, 440), - Trans(2, 27, 3, 440), - Trans(2, 37, 3, 440), - Trans(2, 38, 3, 440), - Trans(2, 40, 3, 440), - Trans(2, 52, 3, 440), - Trans(2, 69, 3, 440), - Trans(2, 75, 3, 440), - Trans(2, 82, 3, 440), - Trans(2, 85, 3, 440), - Trans(2, 87, 3, 440), - Trans(2, 110, 3, 440), - Trans(2, 111, 3, 440), - Trans(4, 38, 6, 441), - Trans(4, 69, 3, 440), - Trans(5, 5, 6, 441), - Trans(5, 6, 6, 441), - Trans(5, 7, 6, 441), - Trans(5, 8, 6, 441), - Trans(5, 9, 6, 441), - Trans(5, 10, 6, 441), - Trans(5, 11, 6, 441), - Trans(5, 18, 6, 441), - Trans(5, 24, 6, 441), - Trans(5, 25, 6, 441), - Trans(5, 26, 6, 441), - Trans(5, 27, 6, 441), - Trans(5, 37, 6, 441), - Trans(5, 38, 6, 441), - Trans(5, 40, 6, 441), - Trans(5, 52, 6, 441), - Trans(5, 69, 6, 441), - Trans(5, 75, 6, 441), - Trans(5, 82, 6, 441), - Trans(5, 85, 6, 441), - Trans(5, 87, 6, 441), - Trans(5, 110, 6, 441), - Trans(5, 111, 6, 441), + Trans(1, 39, 5, -1), + Trans(1, 70, 2, -1), + Trans(2, 5, 3, 447), + Trans(2, 6, 3, 447), + Trans(2, 7, 3, 447), + Trans(2, 8, 3, 447), + Trans(2, 9, 3, 447), + Trans(2, 10, 3, 447), + Trans(2, 11, 3, 447), + Trans(2, 18, 3, 447), + Trans(2, 24, 3, 447), + Trans(2, 25, 3, 447), + Trans(2, 26, 3, 447), + Trans(2, 27, 3, 447), + Trans(2, 38, 3, 447), + Trans(2, 39, 3, 447), + Trans(2, 41, 3, 447), + Trans(2, 53, 3, 447), + Trans(2, 70, 3, 447), + Trans(2, 76, 3, 447), + Trans(2, 83, 3, 447), + Trans(2, 86, 3, 447), + Trans(2, 88, 3, 447), + Trans(2, 111, 3, 447), + Trans(2, 112, 3, 447), + Trans(4, 39, 6, 448), + Trans(4, 70, 3, 447), + Trans(5, 5, 6, 448), + Trans(5, 6, 6, 448), + Trans(5, 7, 6, 448), + Trans(5, 8, 6, 448), + Trans(5, 9, 6, 448), + Trans(5, 10, 6, 448), + Trans(5, 11, 6, 448), + Trans(5, 18, 6, 448), + Trans(5, 24, 6, 448), + Trans(5, 25, 6, 448), + Trans(5, 26, 6, 448), + Trans(5, 27, 6, 448), + Trans(5, 38, 6, 448), + Trans(5, 39, 6, 448), + Trans(5, 41, 6, 448), + Trans(5, 53, 6, 448), + Trans(5, 70, 6, 448), + Trans(5, 76, 6, 448), + Trans(5, 83, 6, 448), + Trans(5, 86, 6, 448), + Trans(5, 88, 6, 448), + Trans(5, 111, 6, 448), + Trans(5, 112, 6, 448), ], k: 3, }, - /* 247 - "IfReset" */ + /* 251 - "IfReset" */ LookaheadDFA { - prod0: 283, + prod0: 286, transitions: &[], k: 0, }, - /* 248 - "IfResetStatement" */ + /* 252 - "IfResetStatement" */ LookaheadDFA { - prod0: 536, + prod0: 543, transitions: &[], k: 0, }, - /* 249 - "IfResetStatementList" */ + /* 253 - "IfResetStatementList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 542), - Trans(0, 52, 1, 541), - Trans(0, 64, 1, 541), - Trans(0, 68, 1, 541), - Trans(0, 69, 1, 541), - Trans(0, 79, 1, 541), - Trans(0, 98, 1, 541), - Trans(0, 99, 1, 541), - Trans(0, 110, 1, 541), - Trans(0, 111, 1, 541), + Trans(0, 43, 2, 549), + Trans(0, 53, 1, 548), + Trans(0, 65, 1, 548), + Trans(0, 69, 1, 548), + Trans(0, 70, 1, 548), + Trans(0, 80, 1, 548), + Trans(0, 99, 1, 548), + Trans(0, 100, 1, 548), + Trans(0, 111, 1, 548), + Trans(0, 112, 1, 548), ], k: 1, }, - /* 250 - "IfResetStatementList0" */ + /* 254 - "IfResetStatementList0" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -5375,957 +5605,1136 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(0, 25, 6, -1), Trans(0, 26, 6, -1), Trans(0, 27, 6, -1), - Trans(0, 37, 7, -1), - Trans(0, 38, 8, -1), - Trans(0, 40, 9, -1), - Trans(0, 42, 10, -1), - Trans(0, 52, 11, -1), - Trans(0, 56, 12, -1), - Trans(0, 57, 1, -1), - Trans(0, 64, 13, -1), - Trans(0, 68, 14, -1), - Trans(0, 69, 11, -1), - Trans(0, 75, 11, -1), - Trans(0, 79, 13, -1), - Trans(0, 82, 5, -1), - Trans(0, 85, 5, -1), - Trans(0, 87, 11, -1), - Trans(0, 98, 15, -1), - Trans(0, 99, 16, -1), - Trans(0, 109, 13, -1), - Trans(0, 110, 17, -1), + Trans(0, 38, 7, -1), + Trans(0, 39, 8, -1), + Trans(0, 41, 9, -1), + Trans(0, 43, 10, -1), + Trans(0, 53, 11, -1), + Trans(0, 57, 12, -1), + Trans(0, 58, 1, -1), + Trans(0, 65, 13, -1), + Trans(0, 69, 14, -1), + Trans(0, 70, 11, -1), + Trans(0, 76, 11, -1), + Trans(0, 80, 13, -1), + Trans(0, 83, 5, -1), + Trans(0, 86, 5, -1), + Trans(0, 88, 11, -1), + Trans(0, 99, 15, -1), + Trans(0, 100, 16, -1), + Trans(0, 110, 13, -1), Trans(0, 111, 17, -1), + Trans(0, 112, 18, -1), Trans(1, 5, 4, -1), - Trans(1, 38, 51, -1), - Trans(1, 69, 2, -1), - Trans(2, 5, 3, 537), - Trans(2, 6, 3, 537), - Trans(2, 7, 3, 537), - Trans(2, 8, 3, 537), - Trans(2, 9, 3, 537), - Trans(2, 10, 3, 537), - Trans(2, 11, 3, 537), - Trans(2, 18, 3, 537), - Trans(2, 24, 3, 537), - Trans(2, 25, 3, 537), - Trans(2, 26, 3, 537), - Trans(2, 27, 3, 537), - Trans(2, 37, 3, 537), - Trans(2, 38, 3, 537), - Trans(2, 40, 3, 537), - Trans(2, 52, 3, 537), - Trans(2, 69, 3, 537), - Trans(2, 75, 3, 537), - Trans(2, 82, 3, 537), - Trans(2, 85, 3, 537), - Trans(2, 87, 3, 537), - Trans(2, 110, 3, 537), - Trans(2, 111, 3, 537), - Trans(4, 38, 34, 540), - Trans(4, 69, 3, 537), - Trans(5, 5, 49, -1), - Trans(5, 16, 20, -1), - Trans(5, 17, 20, -1), - Trans(5, 18, 20, -1), - Trans(5, 19, 20, -1), - Trans(5, 20, 20, -1), - Trans(5, 21, 20, -1), - Trans(5, 22, 20, -1), - Trans(5, 23, 20, -1), - Trans(5, 24, 20, -1), - Trans(5, 25, 20, -1), - Trans(5, 26, 20, -1), - Trans(5, 29, 47, -1), - Trans(5, 30, 20, -1), - Trans(5, 46, 20, -1), - Trans(5, 50, 31, -1), - Trans(6, 5, 35, -1), - Trans(6, 6, 19, -1), - Trans(6, 7, 19, -1), - Trans(6, 8, 19, -1), - Trans(6, 9, 19, -1), - Trans(6, 10, 19, -1), - Trans(6, 11, 19, -1), - Trans(6, 18, 20, -1), - Trans(6, 24, 20, -1), - Trans(6, 25, 20, -1), - Trans(6, 26, 20, -1), - Trans(6, 27, 20, -1), - Trans(6, 37, 23, -1), - Trans(6, 38, 20, -1), - Trans(6, 40, 20, -1), - Trans(6, 52, 20, -1), - Trans(6, 69, 20, -1), - Trans(6, 75, 20, -1), - Trans(6, 82, 19, -1), - Trans(6, 85, 19, -1), - Trans(6, 87, 20, -1), - Trans(6, 110, 36, -1), - Trans(6, 111, 36, -1), - Trans(7, 5, 37, -1), - Trans(7, 6, 38, -1), - Trans(7, 7, 38, -1), - Trans(7, 8, 38, -1), - Trans(7, 9, 38, -1), - Trans(7, 10, 38, -1), - Trans(7, 11, 38, -1), - Trans(7, 18, 20, -1), - Trans(7, 24, 20, -1), - Trans(7, 25, 20, -1), - Trans(7, 26, 20, -1), - Trans(7, 27, 20, -1), - Trans(7, 37, 23, -1), - Trans(7, 38, 20, -1), - Trans(7, 40, 20, -1), - Trans(7, 52, 20, -1), - Trans(7, 56, 28, -1), - Trans(7, 69, 20, -1), - Trans(7, 75, 20, -1), - Trans(7, 82, 38, -1), - Trans(7, 85, 38, -1), - Trans(7, 87, 20, -1), - Trans(7, 110, 39, -1), - Trans(7, 111, 39, -1), - Trans(8, 5, 35, -1), - Trans(8, 6, 38, -1), - Trans(8, 7, 38, -1), - Trans(8, 8, 38, -1), - Trans(8, 9, 38, -1), - Trans(8, 10, 38, -1), - Trans(8, 11, 38, -1), - Trans(8, 18, 20, -1), - Trans(8, 24, 20, -1), - Trans(8, 25, 20, -1), - Trans(8, 26, 20, -1), - Trans(8, 27, 20, -1), - Trans(8, 37, 23, -1), - Trans(8, 38, 20, -1), - Trans(8, 40, 20, -1), - Trans(8, 52, 20, -1), - Trans(8, 69, 20, -1), - Trans(8, 75, 20, -1), - Trans(8, 82, 38, -1), - Trans(8, 85, 38, -1), - Trans(8, 87, 20, -1), - Trans(8, 110, 39, -1), - Trans(8, 111, 39, -1), - Trans(9, 5, 35, -1), - Trans(9, 6, 40, -1), - Trans(9, 7, 40, -1), - Trans(9, 8, 40, -1), - Trans(9, 9, 40, -1), - Trans(9, 10, 40, -1), - Trans(9, 11, 40, -1), - Trans(9, 18, 20, -1), - Trans(9, 24, 20, -1), - Trans(9, 25, 20, -1), - Trans(9, 26, 20, -1), - Trans(9, 27, 20, -1), - Trans(9, 37, 23, -1), - Trans(9, 38, 20, -1), - Trans(9, 40, 20, -1), - Trans(9, 52, 20, -1), - Trans(9, 69, 20, -1), - Trans(9, 75, 20, -1), - Trans(9, 82, 40, -1), - Trans(9, 85, 40, -1), - Trans(9, 87, 20, -1), - Trans(9, 110, 41, -1), - Trans(9, 111, 41, -1), - Trans(10, 5, 18, -1), - Trans(10, 6, 19, -1), - Trans(10, 7, 19, -1), - Trans(10, 8, 19, -1), - Trans(10, 9, 19, -1), - Trans(10, 10, 19, -1), - Trans(10, 11, 19, -1), - Trans(10, 18, 20, -1), - Trans(10, 24, 20, -1), - Trans(10, 25, 20, -1), - Trans(10, 26, 20, -1), - Trans(10, 27, 20, -1), - Trans(10, 29, 21, -1), - Trans(10, 35, 22, -1), - Trans(10, 37, 23, -1), + Trans(1, 39, 60, -1), + Trans(1, 70, 2, -1), + Trans(2, 5, 3, 544), + Trans(2, 6, 3, 544), + Trans(2, 7, 3, 544), + Trans(2, 8, 3, 544), + Trans(2, 9, 3, 544), + Trans(2, 10, 3, 544), + Trans(2, 11, 3, 544), + Trans(2, 18, 3, 544), + Trans(2, 24, 3, 544), + Trans(2, 25, 3, 544), + Trans(2, 26, 3, 544), + Trans(2, 27, 3, 544), + Trans(2, 38, 3, 544), + Trans(2, 39, 3, 544), + Trans(2, 41, 3, 544), + Trans(2, 53, 3, 544), + Trans(2, 70, 3, 544), + Trans(2, 76, 3, 544), + Trans(2, 83, 3, 544), + Trans(2, 86, 3, 544), + Trans(2, 88, 3, 544), + Trans(2, 111, 3, 544), + Trans(2, 112, 3, 544), + Trans(4, 39, 36, 547), + Trans(4, 70, 3, 544), + Trans(5, 5, 58, -1), + Trans(5, 16, 21, -1), + Trans(5, 17, 21, -1), + Trans(5, 18, 21, -1), + Trans(5, 19, 21, -1), + Trans(5, 20, 21, -1), + Trans(5, 21, 21, -1), + Trans(5, 22, 21, -1), + Trans(5, 23, 21, -1), + Trans(5, 24, 21, -1), + Trans(5, 25, 21, -1), + Trans(5, 26, 21, -1), + Trans(5, 30, 54, -1), + Trans(5, 31, 21, -1), + Trans(5, 47, 21, -1), + Trans(5, 51, 32, -1), + Trans(6, 5, 37, -1), + Trans(6, 6, 20, -1), + Trans(6, 7, 20, -1), + Trans(6, 8, 20, -1), + Trans(6, 9, 20, -1), + Trans(6, 10, 20, -1), + Trans(6, 11, 20, -1), + Trans(6, 18, 21, -1), + Trans(6, 24, 21, -1), + Trans(6, 25, 21, -1), + Trans(6, 26, 21, -1), + Trans(6, 27, 21, -1), + Trans(6, 38, 24, -1), + Trans(6, 39, 21, -1), + Trans(6, 41, 21, -1), + Trans(6, 53, 21, -1), + Trans(6, 70, 21, -1), + Trans(6, 76, 21, -1), + Trans(6, 83, 20, -1), + Trans(6, 86, 20, -1), + Trans(6, 88, 21, -1), + Trans(6, 111, 38, -1), + Trans(6, 112, 39, -1), + Trans(7, 5, 40, -1), + Trans(7, 6, 41, -1), + Trans(7, 7, 41, -1), + Trans(7, 8, 41, -1), + Trans(7, 9, 41, -1), + Trans(7, 10, 41, -1), + Trans(7, 11, 41, -1), + Trans(7, 18, 21, -1), + Trans(7, 24, 21, -1), + Trans(7, 25, 21, -1), + Trans(7, 26, 21, -1), + Trans(7, 27, 21, -1), + Trans(7, 38, 24, -1), + Trans(7, 39, 21, -1), + Trans(7, 41, 21, -1), + Trans(7, 53, 21, -1), + Trans(7, 57, 29, -1), + Trans(7, 70, 21, -1), + Trans(7, 76, 21, -1), + Trans(7, 83, 41, -1), + Trans(7, 86, 41, -1), + Trans(7, 88, 21, -1), + Trans(7, 111, 42, -1), + Trans(7, 112, 43, -1), + Trans(8, 5, 37, -1), + Trans(8, 6, 41, -1), + Trans(8, 7, 41, -1), + Trans(8, 8, 41, -1), + Trans(8, 9, 41, -1), + Trans(8, 10, 41, -1), + Trans(8, 11, 41, -1), + Trans(8, 18, 21, -1), + Trans(8, 24, 21, -1), + Trans(8, 25, 21, -1), + Trans(8, 26, 21, -1), + Trans(8, 27, 21, -1), + Trans(8, 38, 24, -1), + Trans(8, 39, 21, -1), + Trans(8, 41, 21, -1), + Trans(8, 53, 21, -1), + Trans(8, 70, 21, -1), + Trans(8, 76, 21, -1), + Trans(8, 83, 41, -1), + Trans(8, 86, 41, -1), + Trans(8, 88, 21, -1), + Trans(8, 111, 42, -1), + Trans(8, 112, 43, -1), + Trans(9, 5, 37, -1), + Trans(9, 6, 44, -1), + Trans(9, 7, 44, -1), + Trans(9, 8, 44, -1), + Trans(9, 9, 44, -1), + Trans(9, 10, 44, -1), + Trans(9, 11, 44, -1), + Trans(9, 18, 21, -1), + Trans(9, 24, 21, -1), + Trans(9, 25, 21, -1), + Trans(9, 26, 21, -1), + Trans(9, 27, 21, -1), + Trans(9, 38, 24, -1), + Trans(9, 39, 21, -1), + Trans(9, 41, 21, -1), + Trans(9, 53, 21, -1), + Trans(9, 70, 21, -1), + Trans(9, 76, 21, -1), + Trans(9, 83, 44, -1), + Trans(9, 86, 44, -1), + Trans(9, 88, 21, -1), + Trans(9, 111, 45, -1), + Trans(9, 112, 46, -1), + Trans(10, 5, 19, -1), + Trans(10, 6, 20, -1), + Trans(10, 7, 20, -1), + Trans(10, 8, 20, -1), + Trans(10, 9, 20, -1), + Trans(10, 10, 20, -1), + Trans(10, 11, 20, -1), + Trans(10, 18, 21, -1), + Trans(10, 24, 21, -1), + Trans(10, 25, 21, -1), + Trans(10, 26, 21, -1), + Trans(10, 27, 21, -1), + Trans(10, 30, 22, -1), + Trans(10, 36, 23, -1), Trans(10, 38, 24, -1), - Trans(10, 40, 20, -1), - Trans(10, 42, 25, -1), - Trans(10, 47, 26, -1), + Trans(10, 39, 25, -1), + Trans(10, 41, 21, -1), + Trans(10, 43, 26, -1), Trans(10, 48, 27, -1), - Trans(10, 49, 21, -1), - Trans(10, 52, 20, -1), - Trans(10, 56, 28, -1), + Trans(10, 49, 28, -1), + Trans(10, 50, 22, -1), + Trans(10, 53, 21, -1), Trans(10, 57, 29, -1), - Trans(10, 59, 21, -1), - Trans(10, 60, 30, -1), - Trans(10, 63, 26, -1), - Trans(10, 64, 21, -1), - Trans(10, 65, 21, -1), - Trans(10, 68, 26, -1), - Trans(10, 69, 20, -1), - Trans(10, 70, 31, -1), - Trans(10, 72, 26, -1), - Trans(10, 75, 20, -1), + Trans(10, 58, 30, -1), + Trans(10, 60, 22, -1), + Trans(10, 61, 31, -1), + Trans(10, 64, 27, -1), + Trans(10, 65, 22, -1), + Trans(10, 66, 22, -1), + Trans(10, 69, 27, -1), + Trans(10, 70, 21, -1), + Trans(10, 71, 32, -1), + Trans(10, 73, 27, -1), Trans(10, 76, 21, -1), - Trans(10, 79, 21, -1), - Trans(10, 80, 21, -1), - Trans(10, 82, 19, -1), - Trans(10, 83, 21, -1), - Trans(10, 85, 19, -1), - Trans(10, 87, 20, -1), - Trans(10, 98, 20, -1), - Trans(10, 99, 32, -1), - Trans(10, 103, 21, -1), - Trans(10, 105, 21, -1), - Trans(10, 108, 21, -1), - Trans(10, 109, 21, -1), - Trans(10, 110, 33, -1), - Trans(10, 111, 33, -1), - Trans(11, 5, 35, -1), - Trans(11, 6, 42, -1), - Trans(11, 7, 42, -1), - Trans(11, 8, 42, -1), - Trans(11, 9, 42, -1), - Trans(11, 10, 42, -1), - Trans(11, 11, 42, -1), - Trans(11, 18, 20, -1), - Trans(11, 24, 20, -1), - Trans(11, 25, 20, -1), - Trans(11, 26, 20, -1), - Trans(11, 27, 20, -1), - Trans(11, 37, 23, -1), - Trans(11, 38, 20, -1), - Trans(11, 40, 20, -1), - Trans(11, 52, 20, -1), - Trans(11, 69, 20, -1), - Trans(11, 75, 20, -1), - Trans(11, 82, 42, -1), - Trans(11, 85, 42, -1), - Trans(11, 87, 20, -1), - Trans(11, 110, 43, -1), - Trans(11, 111, 43, -1), - Trans(12, 5, 50, -1), - Trans(12, 29, 47, -1), - Trans(13, 5, 55, -1), - Trans(13, 111, 28, -1), - Trans(14, 5, 52, -1), - Trans(14, 38, 51, -1), - Trans(15, 5, 35, -1), - Trans(15, 6, 44, -1), - Trans(15, 7, 44, -1), - Trans(15, 8, 44, -1), - Trans(15, 9, 44, -1), - Trans(15, 10, 44, -1), - Trans(15, 11, 44, -1), - Trans(15, 18, 20, -1), - Trans(15, 24, 20, -1), - Trans(15, 25, 20, -1), - Trans(15, 26, 20, -1), - Trans(15, 27, 20, -1), - Trans(15, 37, 23, -1), - Trans(15, 38, 20, -1), - Trans(15, 40, 20, -1), - Trans(15, 52, 20, -1), - Trans(15, 69, 20, -1), - Trans(15, 75, 20, -1), - Trans(15, 82, 44, -1), - Trans(15, 85, 44, -1), - Trans(15, 87, 20, -1), - Trans(15, 110, 45, -1), - Trans(15, 111, 45, -1), - Trans(16, 5, 53, -1), - Trans(16, 45, 54, -1), - Trans(17, 5, 46, -1), - Trans(17, 15, 20, -1), - Trans(17, 16, 20, -1), - Trans(17, 17, 20, -1), - Trans(17, 18, 20, -1), - Trans(17, 19, 20, -1), - Trans(17, 20, 20, -1), - Trans(17, 21, 20, -1), - Trans(17, 22, 20, -1), - Trans(17, 23, 20, -1), - Trans(17, 24, 20, -1), - Trans(17, 25, 20, -1), - Trans(17, 26, 20, -1), - Trans(17, 28, 21, -1), - Trans(17, 29, 47, -1), - Trans(17, 30, 20, -1), - Trans(17, 33, 21, -1), - Trans(17, 34, 20, -1), - Trans(17, 39, 20, -1), - Trans(17, 40, 48, -1), - Trans(17, 46, 20, -1), - Trans(17, 50, 31, -1), - Trans(18, 6, 34, 540), - Trans(18, 7, 34, 540), - Trans(18, 8, 34, 540), - Trans(18, 9, 34, 540), - Trans(18, 10, 34, 540), - Trans(18, 11, 34, 540), - Trans(18, 18, 34, 540), - Trans(18, 24, 34, 540), - Trans(18, 25, 34, 540), - Trans(18, 26, 34, 540), - Trans(18, 27, 34, 540), - Trans(18, 29, 34, 540), - Trans(18, 35, 34, 540), - Trans(18, 37, 34, 540), - Trans(18, 38, 34, 540), - Trans(18, 40, 34, 540), - Trans(18, 42, 34, 540), - Trans(18, 47, 34, 540), - Trans(18, 48, 34, 540), - Trans(18, 49, 34, 540), - Trans(18, 52, 34, 540), - Trans(18, 56, 34, 540), - Trans(18, 57, 34, 540), - Trans(18, 59, 34, 540), - Trans(18, 60, 34, 540), - Trans(18, 63, 34, 540), - Trans(18, 64, 34, 540), - Trans(18, 65, 34, 540), - Trans(18, 68, 34, 540), - Trans(18, 69, 34, 540), - Trans(18, 70, 34, 540), - Trans(18, 72, 34, 540), - Trans(18, 75, 34, 540), - Trans(18, 76, 34, 540), - Trans(18, 79, 34, 540), - Trans(18, 80, 34, 540), - Trans(18, 82, 34, 540), - Trans(18, 83, 34, 540), - Trans(18, 85, 34, 540), - Trans(18, 87, 34, 540), - Trans(18, 98, 34, 540), - Trans(18, 99, 34, 540), - Trans(18, 103, 34, 540), - Trans(18, 105, 34, 540), - Trans(18, 108, 34, 540), - Trans(18, 109, 34, 540), - Trans(18, 110, 34, 540), - Trans(18, 111, 34, 540), - Trans(19, 5, 34, 540), - Trans(19, 16, 34, 540), - Trans(19, 17, 34, 540), - Trans(19, 18, 34, 540), - Trans(19, 19, 34, 540), - Trans(19, 20, 34, 540), - Trans(19, 21, 34, 540), - Trans(19, 22, 34, 540), - Trans(19, 23, 34, 540), - Trans(19, 24, 34, 540), - Trans(19, 25, 34, 540), - Trans(19, 26, 34, 540), - Trans(19, 29, 34, 540), - Trans(19, 30, 34, 540), - Trans(19, 46, 34, 540), - Trans(19, 50, 34, 540), - Trans(20, 5, 34, 540), - Trans(20, 6, 34, 540), - Trans(20, 7, 34, 540), - Trans(20, 8, 34, 540), - Trans(20, 9, 34, 540), - Trans(20, 10, 34, 540), - Trans(20, 11, 34, 540), - Trans(20, 18, 34, 540), - Trans(20, 24, 34, 540), - Trans(20, 25, 34, 540), - Trans(20, 26, 34, 540), - Trans(20, 27, 34, 540), - Trans(20, 37, 34, 540), - Trans(20, 38, 34, 540), - Trans(20, 40, 34, 540), - Trans(20, 52, 34, 540), - Trans(20, 69, 34, 540), - Trans(20, 75, 34, 540), - Trans(20, 82, 34, 540), - Trans(20, 85, 34, 540), - Trans(20, 87, 34, 540), - Trans(20, 110, 34, 540), - Trans(20, 111, 34, 540), - Trans(21, 5, 34, 540), - Trans(21, 111, 34, 540), - Trans(22, 5, 34, 540), - Trans(22, 39, 34, 540), - Trans(23, 5, 34, 540), - Trans(23, 6, 34, 540), - Trans(23, 7, 34, 540), - Trans(23, 8, 34, 540), - Trans(23, 9, 34, 540), - Trans(23, 10, 34, 540), - Trans(23, 11, 34, 540), - Trans(23, 18, 34, 540), - Trans(23, 24, 34, 540), - Trans(23, 25, 34, 540), - Trans(23, 26, 34, 540), - Trans(23, 27, 34, 540), - Trans(23, 37, 34, 540), - Trans(23, 38, 34, 540), - Trans(23, 40, 34, 540), - Trans(23, 52, 34, 540), - Trans(23, 56, 34, 540), - Trans(23, 69, 34, 540), - Trans(23, 75, 34, 540), - Trans(23, 82, 34, 540), - Trans(23, 85, 34, 540), - Trans(23, 87, 34, 540), - Trans(23, 110, 34, 540), - Trans(23, 111, 34, 540), - Trans(24, 5, 34, 540), - Trans(24, 6, 34, 540), - Trans(24, 7, 34, 540), - Trans(24, 8, 34, 540), - Trans(24, 9, 34, 540), - Trans(24, 10, 34, 540), - Trans(24, 11, 34, 540), - Trans(24, 18, 34, 540), - Trans(24, 24, 34, 540), - Trans(24, 25, 34, 540), - Trans(24, 26, 34, 540), - Trans(24, 27, 34, 540), - Trans(24, 29, 34, 540), - Trans(24, 35, 34, 540), - Trans(24, 37, 34, 540), - Trans(24, 38, 34, 540), - Trans(24, 40, 34, 540), - Trans(24, 42, 34, 540), - Trans(24, 47, 34, 540), - Trans(24, 48, 34, 540), - Trans(24, 49, 34, 540), - Trans(24, 52, 34, 540), - Trans(24, 59, 34, 540), - Trans(24, 60, 34, 540), - Trans(24, 63, 34, 540), - Trans(24, 64, 34, 540), - Trans(24, 65, 34, 540), - Trans(24, 69, 34, 540), - Trans(24, 70, 34, 540), - Trans(24, 72, 34, 540), - Trans(24, 75, 34, 540), - Trans(24, 76, 34, 540), - Trans(24, 79, 34, 540), - Trans(24, 80, 34, 540), - Trans(24, 82, 34, 540), - Trans(24, 83, 34, 540), - Trans(24, 85, 34, 540), - Trans(24, 87, 34, 540), - Trans(24, 103, 34, 540), - Trans(24, 105, 34, 540), - Trans(24, 108, 34, 540), - Trans(24, 109, 34, 540), - Trans(24, 110, 34, 540), - Trans(24, 111, 34, 540), - Trans(25, 0, 34, 540), - Trans(25, 5, 34, 540), - Trans(25, 6, 34, 540), - Trans(25, 7, 34, 540), - Trans(25, 8, 34, 540), - Trans(25, 9, 34, 540), - Trans(25, 10, 34, 540), - Trans(25, 11, 34, 540), - Trans(25, 18, 34, 540), - Trans(25, 24, 34, 540), - Trans(25, 25, 34, 540), - Trans(25, 26, 34, 540), - Trans(25, 27, 34, 540), - Trans(25, 29, 34, 540), - Trans(25, 35, 34, 540), - Trans(25, 37, 34, 540), - Trans(25, 38, 34, 540), - Trans(25, 40, 34, 540), - Trans(25, 42, 34, 540), - Trans(25, 47, 34, 540), - Trans(25, 48, 34, 540), - Trans(25, 49, 34, 540), - Trans(25, 52, 34, 540), - Trans(25, 56, 34, 540), - Trans(25, 57, 34, 540), - Trans(25, 58, 34, 540), - Trans(25, 59, 34, 540), - Trans(25, 60, 34, 540), - Trans(25, 63, 34, 540), - Trans(25, 64, 34, 540), - Trans(25, 65, 34, 540), - Trans(25, 68, 34, 540), - Trans(25, 69, 34, 540), - Trans(25, 70, 34, 540), - Trans(25, 71, 34, 540), - Trans(25, 72, 34, 540), - Trans(25, 75, 34, 540), - Trans(25, 76, 34, 540), - Trans(25, 77, 34, 540), - Trans(25, 79, 34, 540), - Trans(25, 80, 34, 540), - Trans(25, 82, 34, 540), - Trans(25, 83, 34, 540), - Trans(25, 84, 34, 540), - Trans(25, 85, 34, 540), - Trans(25, 87, 34, 540), - Trans(25, 88, 34, 540), - Trans(25, 90, 34, 540), - Trans(25, 98, 34, 540), - Trans(25, 99, 34, 540), - Trans(25, 103, 34, 540), - Trans(25, 105, 34, 540), - Trans(25, 108, 34, 540), - Trans(25, 109, 34, 540), - Trans(25, 110, 34, 540), - Trans(25, 111, 34, 540), - Trans(26, 5, 34, 540), - Trans(26, 38, 34, 540), - Trans(27, 5, 34, 540), - Trans(27, 40, 34, 540), - Trans(28, 5, 34, 540), - Trans(28, 29, 34, 540), - Trans(29, 5, 34, 540), - Trans(29, 38, 34, 540), - Trans(29, 69, 34, 540), - Trans(30, 5, 34, 540), - Trans(30, 46, 34, 540), - Trans(30, 110, 34, 540), - Trans(30, 111, 34, 540), - Trans(31, 5, 34, 540), - Trans(31, 110, 34, 540), - Trans(31, 111, 34, 540), - Trans(32, 5, 34, 540), - Trans(32, 45, 34, 540), - Trans(33, 5, 34, 540), - Trans(33, 15, 34, 540), - Trans(33, 16, 34, 540), - Trans(33, 17, 34, 540), - Trans(33, 18, 34, 540), - Trans(33, 19, 34, 540), - Trans(33, 20, 34, 540), - Trans(33, 21, 34, 540), - Trans(33, 22, 34, 540), - Trans(33, 23, 34, 540), - Trans(33, 24, 34, 540), - Trans(33, 25, 34, 540), - Trans(33, 26, 34, 540), - Trans(33, 28, 34, 540), - Trans(33, 29, 34, 540), - Trans(33, 30, 34, 540), - Trans(33, 33, 34, 540), - Trans(33, 34, 34, 540), - Trans(33, 39, 34, 540), - Trans(33, 40, 34, 540), - Trans(33, 46, 34, 540), - Trans(33, 50, 34, 540), - Trans(35, 6, 34, 540), - Trans(35, 7, 34, 540), - Trans(35, 8, 34, 540), - Trans(35, 9, 34, 540), - Trans(35, 10, 34, 540), - Trans(35, 11, 34, 540), - Trans(35, 18, 34, 540), - Trans(35, 24, 34, 540), - Trans(35, 25, 34, 540), - Trans(35, 26, 34, 540), - Trans(35, 27, 34, 540), - Trans(35, 37, 34, 540), - Trans(35, 38, 34, 540), - Trans(35, 40, 34, 540), - Trans(35, 52, 34, 540), - Trans(35, 69, 34, 540), - Trans(35, 75, 34, 540), - Trans(35, 82, 34, 540), - Trans(35, 85, 34, 540), - Trans(35, 87, 34, 540), - Trans(35, 110, 34, 540), - Trans(35, 111, 34, 540), - Trans(36, 5, 34, 540), - Trans(36, 16, 34, 540), - Trans(36, 17, 34, 540), - Trans(36, 18, 34, 540), - Trans(36, 19, 34, 540), - Trans(36, 20, 34, 540), - Trans(36, 21, 34, 540), - Trans(36, 22, 34, 540), - Trans(36, 23, 34, 540), - Trans(36, 24, 34, 540), - Trans(36, 25, 34, 540), - Trans(36, 26, 34, 540), - Trans(36, 28, 34, 540), - Trans(36, 29, 34, 540), - Trans(36, 30, 34, 540), - Trans(36, 33, 34, 540), - Trans(36, 39, 34, 540), - Trans(36, 40, 34, 540), - Trans(36, 46, 34, 540), - Trans(36, 50, 34, 540), - Trans(37, 6, 34, 540), - Trans(37, 7, 34, 540), - Trans(37, 8, 34, 540), - Trans(37, 9, 34, 540), - Trans(37, 10, 34, 540), - Trans(37, 11, 34, 540), - Trans(37, 18, 34, 540), - Trans(37, 24, 34, 540), - Trans(37, 25, 34, 540), - Trans(37, 26, 34, 540), - Trans(37, 27, 34, 540), - Trans(37, 37, 34, 540), - Trans(37, 38, 34, 540), - Trans(37, 40, 34, 540), - Trans(37, 52, 34, 540), - Trans(37, 56, 34, 540), - Trans(37, 69, 34, 540), - Trans(37, 75, 34, 540), - Trans(37, 82, 34, 540), - Trans(37, 85, 34, 540), - Trans(37, 87, 34, 540), - Trans(37, 110, 34, 540), - Trans(37, 111, 34, 540), - Trans(38, 5, 34, 540), - Trans(38, 16, 34, 540), - Trans(38, 17, 34, 540), - Trans(38, 18, 34, 540), - Trans(38, 19, 34, 540), - Trans(38, 20, 34, 540), - Trans(38, 21, 34, 540), - Trans(38, 22, 34, 540), - Trans(38, 23, 34, 540), - Trans(38, 24, 34, 540), - Trans(38, 25, 34, 540), - Trans(38, 26, 34, 540), - Trans(38, 30, 34, 540), - Trans(38, 42, 34, 540), - Trans(38, 46, 34, 540), - Trans(38, 50, 34, 540), - Trans(38, 92, 34, 540), - Trans(39, 5, 34, 540), - Trans(39, 16, 34, 540), - Trans(39, 17, 34, 540), - Trans(39, 18, 34, 540), - Trans(39, 19, 34, 540), - Trans(39, 20, 34, 540), - Trans(39, 21, 34, 540), - Trans(39, 22, 34, 540), - Trans(39, 23, 34, 540), - Trans(39, 24, 34, 540), - Trans(39, 25, 34, 540), - Trans(39, 26, 34, 540), - Trans(39, 28, 34, 540), - Trans(39, 30, 34, 540), - Trans(39, 33, 34, 540), - Trans(39, 39, 34, 540), - Trans(39, 40, 34, 540), - Trans(39, 42, 34, 540), - Trans(39, 46, 34, 540), - Trans(39, 50, 34, 540), - Trans(39, 92, 34, 540), - Trans(40, 5, 34, 540), - Trans(40, 16, 34, 540), - Trans(40, 17, 34, 540), - Trans(40, 18, 34, 540), - Trans(40, 19, 34, 540), - Trans(40, 20, 34, 540), - Trans(40, 21, 34, 540), - Trans(40, 22, 34, 540), - Trans(40, 23, 34, 540), - Trans(40, 24, 34, 540), - Trans(40, 25, 34, 540), - Trans(40, 26, 34, 540), - Trans(40, 44, 34, 540), - Trans(40, 46, 34, 540), - Trans(40, 50, 34, 540), - Trans(41, 5, 34, 540), - Trans(41, 16, 34, 540), - Trans(41, 17, 34, 540), - Trans(41, 18, 34, 540), - Trans(41, 19, 34, 540), - Trans(41, 20, 34, 540), - Trans(41, 21, 34, 540), - Trans(41, 22, 34, 540), - Trans(41, 23, 34, 540), - Trans(41, 24, 34, 540), - Trans(41, 25, 34, 540), - Trans(41, 26, 34, 540), - Trans(41, 28, 34, 540), - Trans(41, 33, 34, 540), - Trans(41, 39, 34, 540), - Trans(41, 40, 34, 540), - Trans(41, 44, 34, 540), - Trans(41, 46, 34, 540), - Trans(41, 50, 34, 540), - Trans(42, 5, 34, 540), - Trans(42, 16, 34, 540), - Trans(42, 17, 34, 540), - Trans(42, 18, 34, 540), - Trans(42, 19, 34, 540), - Trans(42, 20, 34, 540), - Trans(42, 21, 34, 540), - Trans(42, 22, 34, 540), - Trans(42, 23, 34, 540), - Trans(42, 24, 34, 540), - Trans(42, 25, 34, 540), - Trans(42, 26, 34, 540), - Trans(42, 38, 34, 540), - Trans(42, 46, 34, 540), - Trans(42, 50, 34, 540), - Trans(43, 5, 34, 540), - Trans(43, 16, 34, 540), - Trans(43, 17, 34, 540), - Trans(43, 18, 34, 540), - Trans(43, 19, 34, 540), - Trans(43, 20, 34, 540), - Trans(43, 21, 34, 540), - Trans(43, 22, 34, 540), - Trans(43, 23, 34, 540), - Trans(43, 24, 34, 540), - Trans(43, 25, 34, 540), - Trans(43, 26, 34, 540), - Trans(43, 28, 34, 540), - Trans(43, 33, 34, 540), - Trans(43, 38, 34, 540), - Trans(43, 39, 34, 540), - Trans(43, 40, 34, 540), - Trans(43, 46, 34, 540), - Trans(43, 50, 34, 540), - Trans(44, 5, 34, 540), - Trans(44, 16, 34, 540), - Trans(44, 17, 34, 540), - Trans(44, 18, 34, 540), - Trans(44, 19, 34, 540), - Trans(44, 20, 34, 540), - Trans(44, 21, 34, 540), - Trans(44, 22, 34, 540), - Trans(44, 23, 34, 540), - Trans(44, 24, 34, 540), - Trans(44, 25, 34, 540), - Trans(44, 26, 34, 540), - Trans(44, 45, 34, 540), - Trans(44, 46, 34, 540), - Trans(44, 50, 34, 540), - Trans(45, 5, 34, 540), - Trans(45, 16, 34, 540), - Trans(45, 17, 34, 540), - Trans(45, 18, 34, 540), - Trans(45, 19, 34, 540), - Trans(45, 20, 34, 540), - Trans(45, 21, 34, 540), - Trans(45, 22, 34, 540), - Trans(45, 23, 34, 540), - Trans(45, 24, 34, 540), - Trans(45, 25, 34, 540), - Trans(45, 26, 34, 540), - Trans(45, 28, 34, 540), - Trans(45, 33, 34, 540), - Trans(45, 39, 34, 540), - Trans(45, 40, 34, 540), - Trans(45, 45, 34, 540), - Trans(45, 46, 34, 540), - Trans(45, 50, 34, 540), - Trans(46, 15, 34, 540), - Trans(46, 16, 34, 540), - Trans(46, 17, 34, 540), - Trans(46, 18, 34, 540), - Trans(46, 19, 34, 540), - Trans(46, 20, 34, 540), - Trans(46, 21, 34, 540), - Trans(46, 22, 34, 540), - Trans(46, 23, 34, 540), - Trans(46, 24, 34, 540), - Trans(46, 25, 34, 540), - Trans(46, 26, 34, 540), - Trans(46, 28, 34, 540), - Trans(46, 29, 34, 540), - Trans(46, 30, 34, 540), - Trans(46, 33, 34, 540), - Trans(46, 34, 34, 540), - Trans(46, 39, 34, 540), - Trans(46, 40, 34, 540), - Trans(46, 46, 34, 540), - Trans(46, 50, 34, 540), - Trans(47, 5, 34, 540), - Trans(47, 38, 34, 540), - Trans(47, 52, 34, 540), - Trans(47, 64, 34, 540), - Trans(47, 68, 34, 540), - Trans(47, 69, 34, 540), - Trans(47, 79, 34, 540), - Trans(47, 98, 34, 540), - Trans(47, 99, 34, 540), - Trans(47, 110, 34, 540), - Trans(47, 111, 34, 540), - Trans(48, 5, 34, 540), - Trans(48, 6, 34, 540), - Trans(48, 7, 34, 540), - Trans(48, 8, 34, 540), - Trans(48, 9, 34, 540), - Trans(48, 10, 34, 540), - Trans(48, 11, 34, 540), - Trans(48, 18, 34, 540), - Trans(48, 24, 34, 540), - Trans(48, 25, 34, 540), - Trans(48, 26, 34, 540), - Trans(48, 27, 34, 540), - Trans(48, 37, 34, 540), - Trans(48, 38, 34, 540), - Trans(48, 40, 34, 540), - Trans(48, 44, 34, 540), - Trans(48, 52, 34, 540), - Trans(48, 69, 34, 540), - Trans(48, 75, 34, 540), - Trans(48, 82, 34, 540), - Trans(48, 85, 34, 540), - Trans(48, 87, 34, 540), - Trans(48, 110, 34, 540), - Trans(48, 111, 34, 540), - Trans(49, 16, 34, 540), - Trans(49, 17, 34, 540), - Trans(49, 18, 34, 540), - Trans(49, 19, 34, 540), - Trans(49, 20, 34, 540), - Trans(49, 21, 34, 540), - Trans(49, 22, 34, 540), - Trans(49, 23, 34, 540), - Trans(49, 24, 34, 540), - Trans(49, 25, 34, 540), - Trans(49, 26, 34, 540), - Trans(49, 29, 34, 540), - Trans(49, 30, 34, 540), - Trans(49, 46, 34, 540), - Trans(49, 50, 34, 540), - Trans(50, 29, 34, 540), - Trans(51, 5, 34, 540), - Trans(51, 42, 34, 540), - Trans(51, 52, 34, 540), - Trans(51, 64, 34, 540), - Trans(51, 68, 34, 540), - Trans(51, 69, 34, 540), - Trans(51, 79, 34, 540), - Trans(51, 98, 34, 540), - Trans(51, 99, 34, 540), - Trans(51, 110, 34, 540), - Trans(51, 111, 34, 540), - Trans(52, 38, 34, 540), - Trans(53, 45, 34, 540), - Trans(54, 5, 34, 540), - Trans(54, 42, 34, 540), - Trans(54, 52, 34, 540), - Trans(54, 64, 34, 540), - Trans(54, 68, 34, 540), - Trans(54, 69, 34, 540), - Trans(54, 79, 34, 540), - Trans(54, 98, 34, 540), - Trans(54, 99, 34, 540), - Trans(54, 109, 34, 540), - Trans(54, 110, 34, 540), - Trans(54, 111, 34, 540), - Trans(55, 111, 34, 540), + Trans(10, 77, 22, -1), + Trans(10, 80, 22, -1), + Trans(10, 81, 22, -1), + Trans(10, 83, 20, -1), + Trans(10, 84, 22, -1), + Trans(10, 86, 20, -1), + Trans(10, 88, 21, -1), + Trans(10, 99, 21, -1), + Trans(10, 100, 33, -1), + Trans(10, 104, 22, -1), + Trans(10, 106, 22, -1), + Trans(10, 109, 22, -1), + Trans(10, 110, 22, -1), + Trans(10, 111, 34, -1), + Trans(10, 112, 35, -1), + Trans(11, 5, 37, -1), + Trans(11, 6, 47, -1), + Trans(11, 7, 47, -1), + Trans(11, 8, 47, -1), + Trans(11, 9, 47, -1), + Trans(11, 10, 47, -1), + Trans(11, 11, 47, -1), + Trans(11, 18, 21, -1), + Trans(11, 24, 21, -1), + Trans(11, 25, 21, -1), + Trans(11, 26, 21, -1), + Trans(11, 27, 21, -1), + Trans(11, 38, 24, -1), + Trans(11, 39, 21, -1), + Trans(11, 41, 21, -1), + Trans(11, 53, 21, -1), + Trans(11, 70, 21, -1), + Trans(11, 76, 21, -1), + Trans(11, 83, 47, -1), + Trans(11, 86, 47, -1), + Trans(11, 88, 21, -1), + Trans(11, 111, 48, -1), + Trans(11, 112, 49, -1), + Trans(12, 5, 59, -1), + Trans(12, 30, 54, -1), + Trans(13, 5, 64, -1), + Trans(13, 112, 29, -1), + Trans(14, 5, 61, -1), + Trans(14, 39, 60, -1), + Trans(15, 5, 37, -1), + Trans(15, 6, 50, -1), + Trans(15, 7, 50, -1), + Trans(15, 8, 50, -1), + Trans(15, 9, 50, -1), + Trans(15, 10, 50, -1), + Trans(15, 11, 50, -1), + Trans(15, 18, 21, -1), + Trans(15, 24, 21, -1), + Trans(15, 25, 21, -1), + Trans(15, 26, 21, -1), + Trans(15, 27, 21, -1), + Trans(15, 38, 24, -1), + Trans(15, 39, 21, -1), + Trans(15, 41, 21, -1), + Trans(15, 53, 21, -1), + Trans(15, 70, 21, -1), + Trans(15, 76, 21, -1), + Trans(15, 83, 50, -1), + Trans(15, 86, 50, -1), + Trans(15, 88, 21, -1), + Trans(15, 111, 51, -1), + Trans(15, 112, 52, -1), + Trans(16, 5, 62, -1), + Trans(16, 46, 63, -1), + Trans(17, 5, 53, -1), + Trans(17, 15, 21, -1), + Trans(17, 16, 21, -1), + Trans(17, 17, 21, -1), + Trans(17, 18, 21, -1), + Trans(17, 19, 21, -1), + Trans(17, 20, 21, -1), + Trans(17, 21, 21, -1), + Trans(17, 22, 21, -1), + Trans(17, 23, 21, -1), + Trans(17, 24, 21, -1), + Trans(17, 25, 21, -1), + Trans(17, 26, 21, -1), + Trans(17, 29, 22, -1), + Trans(17, 30, 54, -1), + Trans(17, 31, 21, -1), + Trans(17, 34, 22, -1), + Trans(17, 35, 21, -1), + Trans(17, 40, 21, -1), + Trans(17, 41, 55, -1), + Trans(17, 47, 21, -1), + Trans(17, 51, 32, -1), + Trans(18, 5, 56, -1), + Trans(18, 15, 21, -1), + Trans(18, 16, 21, -1), + Trans(18, 17, 21, -1), + Trans(18, 18, 21, -1), + Trans(18, 19, 21, -1), + Trans(18, 20, 21, -1), + Trans(18, 21, 21, -1), + Trans(18, 22, 21, -1), + Trans(18, 23, 21, -1), + Trans(18, 24, 21, -1), + Trans(18, 25, 21, -1), + Trans(18, 26, 21, -1), + Trans(18, 28, 57, -1), + Trans(18, 29, 22, -1), + Trans(18, 30, 54, -1), + Trans(18, 31, 21, -1), + Trans(18, 34, 22, -1), + Trans(18, 35, 21, -1), + Trans(18, 40, 21, -1), + Trans(18, 41, 55, -1), + Trans(18, 47, 21, -1), + Trans(18, 51, 32, -1), + Trans(19, 6, 36, 547), + Trans(19, 7, 36, 547), + Trans(19, 8, 36, 547), + Trans(19, 9, 36, 547), + Trans(19, 10, 36, 547), + Trans(19, 11, 36, 547), + Trans(19, 18, 36, 547), + Trans(19, 24, 36, 547), + Trans(19, 25, 36, 547), + Trans(19, 26, 36, 547), + Trans(19, 27, 36, 547), + Trans(19, 30, 36, 547), + Trans(19, 36, 36, 547), + Trans(19, 38, 36, 547), + Trans(19, 39, 36, 547), + Trans(19, 41, 36, 547), + Trans(19, 43, 36, 547), + Trans(19, 48, 36, 547), + Trans(19, 49, 36, 547), + Trans(19, 50, 36, 547), + Trans(19, 53, 36, 547), + Trans(19, 57, 36, 547), + Trans(19, 58, 36, 547), + Trans(19, 60, 36, 547), + Trans(19, 61, 36, 547), + Trans(19, 64, 36, 547), + Trans(19, 65, 36, 547), + Trans(19, 66, 36, 547), + Trans(19, 69, 36, 547), + Trans(19, 70, 36, 547), + Trans(19, 71, 36, 547), + Trans(19, 73, 36, 547), + Trans(19, 76, 36, 547), + Trans(19, 77, 36, 547), + Trans(19, 80, 36, 547), + Trans(19, 81, 36, 547), + Trans(19, 83, 36, 547), + Trans(19, 84, 36, 547), + Trans(19, 86, 36, 547), + Trans(19, 88, 36, 547), + Trans(19, 99, 36, 547), + Trans(19, 100, 36, 547), + Trans(19, 104, 36, 547), + Trans(19, 106, 36, 547), + Trans(19, 109, 36, 547), + Trans(19, 110, 36, 547), + Trans(19, 111, 36, 547), + Trans(19, 112, 36, 547), + Trans(20, 5, 36, 547), + Trans(20, 16, 36, 547), + Trans(20, 17, 36, 547), + Trans(20, 18, 36, 547), + Trans(20, 19, 36, 547), + Trans(20, 20, 36, 547), + Trans(20, 21, 36, 547), + Trans(20, 22, 36, 547), + Trans(20, 23, 36, 547), + Trans(20, 24, 36, 547), + Trans(20, 25, 36, 547), + Trans(20, 26, 36, 547), + Trans(20, 30, 36, 547), + Trans(20, 31, 36, 547), + Trans(20, 47, 36, 547), + Trans(20, 51, 36, 547), + Trans(21, 5, 36, 547), + Trans(21, 6, 36, 547), + Trans(21, 7, 36, 547), + Trans(21, 8, 36, 547), + Trans(21, 9, 36, 547), + Trans(21, 10, 36, 547), + Trans(21, 11, 36, 547), + Trans(21, 18, 36, 547), + Trans(21, 24, 36, 547), + Trans(21, 25, 36, 547), + Trans(21, 26, 36, 547), + Trans(21, 27, 36, 547), + Trans(21, 38, 36, 547), + Trans(21, 39, 36, 547), + Trans(21, 41, 36, 547), + Trans(21, 53, 36, 547), + Trans(21, 70, 36, 547), + Trans(21, 76, 36, 547), + Trans(21, 83, 36, 547), + Trans(21, 86, 36, 547), + Trans(21, 88, 36, 547), + Trans(21, 111, 36, 547), + Trans(21, 112, 36, 547), + Trans(22, 5, 36, 547), + Trans(22, 112, 36, 547), + Trans(23, 5, 36, 547), + Trans(23, 40, 36, 547), + Trans(24, 5, 36, 547), + Trans(24, 6, 36, 547), + Trans(24, 7, 36, 547), + Trans(24, 8, 36, 547), + Trans(24, 9, 36, 547), + Trans(24, 10, 36, 547), + Trans(24, 11, 36, 547), + Trans(24, 18, 36, 547), + Trans(24, 24, 36, 547), + Trans(24, 25, 36, 547), + Trans(24, 26, 36, 547), + Trans(24, 27, 36, 547), + Trans(24, 38, 36, 547), + Trans(24, 39, 36, 547), + Trans(24, 41, 36, 547), + Trans(24, 53, 36, 547), + Trans(24, 57, 36, 547), + Trans(24, 70, 36, 547), + Trans(24, 76, 36, 547), + Trans(24, 83, 36, 547), + Trans(24, 86, 36, 547), + Trans(24, 88, 36, 547), + Trans(24, 111, 36, 547), + Trans(24, 112, 36, 547), + Trans(25, 5, 36, 547), + Trans(25, 6, 36, 547), + Trans(25, 7, 36, 547), + Trans(25, 8, 36, 547), + Trans(25, 9, 36, 547), + Trans(25, 10, 36, 547), + Trans(25, 11, 36, 547), + Trans(25, 18, 36, 547), + Trans(25, 24, 36, 547), + Trans(25, 25, 36, 547), + Trans(25, 26, 36, 547), + Trans(25, 27, 36, 547), + Trans(25, 30, 36, 547), + Trans(25, 36, 36, 547), + Trans(25, 38, 36, 547), + Trans(25, 39, 36, 547), + Trans(25, 41, 36, 547), + Trans(25, 43, 36, 547), + Trans(25, 48, 36, 547), + Trans(25, 49, 36, 547), + Trans(25, 50, 36, 547), + Trans(25, 53, 36, 547), + Trans(25, 60, 36, 547), + Trans(25, 61, 36, 547), + Trans(25, 64, 36, 547), + Trans(25, 65, 36, 547), + Trans(25, 66, 36, 547), + Trans(25, 70, 36, 547), + Trans(25, 71, 36, 547), + Trans(25, 73, 36, 547), + Trans(25, 76, 36, 547), + Trans(25, 77, 36, 547), + Trans(25, 80, 36, 547), + Trans(25, 81, 36, 547), + Trans(25, 83, 36, 547), + Trans(25, 84, 36, 547), + Trans(25, 86, 36, 547), + Trans(25, 88, 36, 547), + Trans(25, 104, 36, 547), + Trans(25, 106, 36, 547), + Trans(25, 109, 36, 547), + Trans(25, 110, 36, 547), + Trans(25, 111, 36, 547), + Trans(25, 112, 36, 547), + Trans(26, 0, 36, 547), + Trans(26, 5, 36, 547), + Trans(26, 6, 36, 547), + Trans(26, 7, 36, 547), + Trans(26, 8, 36, 547), + Trans(26, 9, 36, 547), + Trans(26, 10, 36, 547), + Trans(26, 11, 36, 547), + Trans(26, 18, 36, 547), + Trans(26, 24, 36, 547), + Trans(26, 25, 36, 547), + Trans(26, 26, 36, 547), + Trans(26, 27, 36, 547), + Trans(26, 30, 36, 547), + Trans(26, 36, 36, 547), + Trans(26, 38, 36, 547), + Trans(26, 39, 36, 547), + Trans(26, 41, 36, 547), + Trans(26, 43, 36, 547), + Trans(26, 48, 36, 547), + Trans(26, 49, 36, 547), + Trans(26, 50, 36, 547), + Trans(26, 53, 36, 547), + Trans(26, 57, 36, 547), + Trans(26, 58, 36, 547), + Trans(26, 59, 36, 547), + Trans(26, 60, 36, 547), + Trans(26, 61, 36, 547), + Trans(26, 64, 36, 547), + Trans(26, 65, 36, 547), + Trans(26, 66, 36, 547), + Trans(26, 69, 36, 547), + Trans(26, 70, 36, 547), + Trans(26, 71, 36, 547), + Trans(26, 72, 36, 547), + Trans(26, 73, 36, 547), + Trans(26, 76, 36, 547), + Trans(26, 77, 36, 547), + Trans(26, 78, 36, 547), + Trans(26, 80, 36, 547), + Trans(26, 81, 36, 547), + Trans(26, 83, 36, 547), + Trans(26, 84, 36, 547), + Trans(26, 85, 36, 547), + Trans(26, 86, 36, 547), + Trans(26, 88, 36, 547), + Trans(26, 89, 36, 547), + Trans(26, 91, 36, 547), + Trans(26, 99, 36, 547), + Trans(26, 100, 36, 547), + Trans(26, 104, 36, 547), + Trans(26, 106, 36, 547), + Trans(26, 109, 36, 547), + Trans(26, 110, 36, 547), + Trans(26, 111, 36, 547), + Trans(26, 112, 36, 547), + Trans(27, 5, 36, 547), + Trans(27, 39, 36, 547), + Trans(28, 5, 36, 547), + Trans(28, 41, 36, 547), + Trans(29, 5, 36, 547), + Trans(29, 30, 36, 547), + Trans(30, 5, 36, 547), + Trans(30, 39, 36, 547), + Trans(30, 70, 36, 547), + Trans(31, 5, 36, 547), + Trans(31, 47, 36, 547), + Trans(31, 111, 36, 547), + Trans(31, 112, 36, 547), + Trans(32, 5, 36, 547), + Trans(32, 111, 36, 547), + Trans(32, 112, 36, 547), + Trans(33, 5, 36, 547), + Trans(33, 46, 36, 547), + Trans(34, 5, 36, 547), + Trans(34, 15, 36, 547), + Trans(34, 16, 36, 547), + Trans(34, 17, 36, 547), + Trans(34, 18, 36, 547), + Trans(34, 19, 36, 547), + Trans(34, 20, 36, 547), + Trans(34, 21, 36, 547), + Trans(34, 22, 36, 547), + Trans(34, 23, 36, 547), + Trans(34, 24, 36, 547), + Trans(34, 25, 36, 547), + Trans(34, 26, 36, 547), + Trans(34, 29, 36, 547), + Trans(34, 30, 36, 547), + Trans(34, 31, 36, 547), + Trans(34, 34, 36, 547), + Trans(34, 35, 36, 547), + Trans(34, 40, 36, 547), + Trans(34, 41, 36, 547), + Trans(34, 47, 36, 547), + Trans(34, 51, 36, 547), + Trans(35, 5, 36, 547), + Trans(35, 15, 36, 547), + Trans(35, 16, 36, 547), + Trans(35, 17, 36, 547), + Trans(35, 18, 36, 547), + Trans(35, 19, 36, 547), + Trans(35, 20, 36, 547), + Trans(35, 21, 36, 547), + Trans(35, 22, 36, 547), + Trans(35, 23, 36, 547), + Trans(35, 24, 36, 547), + Trans(35, 25, 36, 547), + Trans(35, 26, 36, 547), + Trans(35, 28, 36, 547), + Trans(35, 29, 36, 547), + Trans(35, 30, 36, 547), + Trans(35, 31, 36, 547), + Trans(35, 34, 36, 547), + Trans(35, 35, 36, 547), + Trans(35, 40, 36, 547), + Trans(35, 41, 36, 547), + Trans(35, 47, 36, 547), + Trans(35, 51, 36, 547), + Trans(37, 6, 36, 547), + Trans(37, 7, 36, 547), + Trans(37, 8, 36, 547), + Trans(37, 9, 36, 547), + Trans(37, 10, 36, 547), + Trans(37, 11, 36, 547), + Trans(37, 18, 36, 547), + Trans(37, 24, 36, 547), + Trans(37, 25, 36, 547), + Trans(37, 26, 36, 547), + Trans(37, 27, 36, 547), + Trans(37, 38, 36, 547), + Trans(37, 39, 36, 547), + Trans(37, 41, 36, 547), + Trans(37, 53, 36, 547), + Trans(37, 70, 36, 547), + Trans(37, 76, 36, 547), + Trans(37, 83, 36, 547), + Trans(37, 86, 36, 547), + Trans(37, 88, 36, 547), + Trans(37, 111, 36, 547), + Trans(37, 112, 36, 547), + Trans(38, 5, 36, 547), + Trans(38, 16, 36, 547), + Trans(38, 17, 36, 547), + Trans(38, 18, 36, 547), + Trans(38, 19, 36, 547), + Trans(38, 20, 36, 547), + Trans(38, 21, 36, 547), + Trans(38, 22, 36, 547), + Trans(38, 23, 36, 547), + Trans(38, 24, 36, 547), + Trans(38, 25, 36, 547), + Trans(38, 26, 36, 547), + Trans(38, 29, 36, 547), + Trans(38, 30, 36, 547), + Trans(38, 31, 36, 547), + Trans(38, 34, 36, 547), + Trans(38, 40, 36, 547), + Trans(38, 41, 36, 547), + Trans(38, 47, 36, 547), + Trans(38, 51, 36, 547), + Trans(39, 5, 36, 547), + Trans(39, 16, 36, 547), + Trans(39, 17, 36, 547), + Trans(39, 18, 36, 547), + Trans(39, 19, 36, 547), + Trans(39, 20, 36, 547), + Trans(39, 21, 36, 547), + Trans(39, 22, 36, 547), + Trans(39, 23, 36, 547), + Trans(39, 24, 36, 547), + Trans(39, 25, 36, 547), + Trans(39, 26, 36, 547), + Trans(39, 28, 36, 547), + Trans(39, 29, 36, 547), + Trans(39, 30, 36, 547), + Trans(39, 31, 36, 547), + Trans(39, 34, 36, 547), + Trans(39, 40, 36, 547), + Trans(39, 41, 36, 547), + Trans(39, 47, 36, 547), + Trans(39, 51, 36, 547), + Trans(40, 6, 36, 547), + Trans(40, 7, 36, 547), + Trans(40, 8, 36, 547), + Trans(40, 9, 36, 547), + Trans(40, 10, 36, 547), + Trans(40, 11, 36, 547), + Trans(40, 18, 36, 547), + Trans(40, 24, 36, 547), + Trans(40, 25, 36, 547), + Trans(40, 26, 36, 547), + Trans(40, 27, 36, 547), + Trans(40, 38, 36, 547), + Trans(40, 39, 36, 547), + Trans(40, 41, 36, 547), + Trans(40, 53, 36, 547), + Trans(40, 57, 36, 547), + Trans(40, 70, 36, 547), + Trans(40, 76, 36, 547), + Trans(40, 83, 36, 547), + Trans(40, 86, 36, 547), + Trans(40, 88, 36, 547), + Trans(40, 111, 36, 547), + Trans(40, 112, 36, 547), + Trans(41, 5, 36, 547), + Trans(41, 16, 36, 547), + Trans(41, 17, 36, 547), + Trans(41, 18, 36, 547), + Trans(41, 19, 36, 547), + Trans(41, 20, 36, 547), + Trans(41, 21, 36, 547), + Trans(41, 22, 36, 547), + Trans(41, 23, 36, 547), + Trans(41, 24, 36, 547), + Trans(41, 25, 36, 547), + Trans(41, 26, 36, 547), + Trans(41, 31, 36, 547), + Trans(41, 43, 36, 547), + Trans(41, 47, 36, 547), + Trans(41, 51, 36, 547), + Trans(41, 93, 36, 547), + Trans(42, 5, 36, 547), + Trans(42, 16, 36, 547), + Trans(42, 17, 36, 547), + Trans(42, 18, 36, 547), + Trans(42, 19, 36, 547), + Trans(42, 20, 36, 547), + Trans(42, 21, 36, 547), + Trans(42, 22, 36, 547), + Trans(42, 23, 36, 547), + Trans(42, 24, 36, 547), + Trans(42, 25, 36, 547), + Trans(42, 26, 36, 547), + Trans(42, 29, 36, 547), + Trans(42, 31, 36, 547), + Trans(42, 34, 36, 547), + Trans(42, 40, 36, 547), + Trans(42, 41, 36, 547), + Trans(42, 43, 36, 547), + Trans(42, 47, 36, 547), + Trans(42, 51, 36, 547), + Trans(42, 93, 36, 547), + Trans(43, 5, 36, 547), + Trans(43, 16, 36, 547), + Trans(43, 17, 36, 547), + Trans(43, 18, 36, 547), + Trans(43, 19, 36, 547), + Trans(43, 20, 36, 547), + Trans(43, 21, 36, 547), + Trans(43, 22, 36, 547), + Trans(43, 23, 36, 547), + Trans(43, 24, 36, 547), + Trans(43, 25, 36, 547), + Trans(43, 26, 36, 547), + Trans(43, 28, 36, 547), + Trans(43, 29, 36, 547), + Trans(43, 31, 36, 547), + Trans(43, 34, 36, 547), + Trans(43, 40, 36, 547), + Trans(43, 41, 36, 547), + Trans(43, 43, 36, 547), + Trans(43, 47, 36, 547), + Trans(43, 51, 36, 547), + Trans(43, 93, 36, 547), + Trans(44, 5, 36, 547), + Trans(44, 16, 36, 547), + Trans(44, 17, 36, 547), + Trans(44, 18, 36, 547), + Trans(44, 19, 36, 547), + Trans(44, 20, 36, 547), + Trans(44, 21, 36, 547), + Trans(44, 22, 36, 547), + Trans(44, 23, 36, 547), + Trans(44, 24, 36, 547), + Trans(44, 25, 36, 547), + Trans(44, 26, 36, 547), + Trans(44, 45, 36, 547), + Trans(44, 47, 36, 547), + Trans(44, 51, 36, 547), + Trans(45, 5, 36, 547), + Trans(45, 16, 36, 547), + Trans(45, 17, 36, 547), + Trans(45, 18, 36, 547), + Trans(45, 19, 36, 547), + Trans(45, 20, 36, 547), + Trans(45, 21, 36, 547), + Trans(45, 22, 36, 547), + Trans(45, 23, 36, 547), + Trans(45, 24, 36, 547), + Trans(45, 25, 36, 547), + Trans(45, 26, 36, 547), + Trans(45, 29, 36, 547), + Trans(45, 34, 36, 547), + Trans(45, 40, 36, 547), + Trans(45, 41, 36, 547), + Trans(45, 45, 36, 547), + Trans(45, 47, 36, 547), + Trans(45, 51, 36, 547), + Trans(46, 5, 36, 547), + Trans(46, 16, 36, 547), + Trans(46, 17, 36, 547), + Trans(46, 18, 36, 547), + Trans(46, 19, 36, 547), + Trans(46, 20, 36, 547), + Trans(46, 21, 36, 547), + Trans(46, 22, 36, 547), + Trans(46, 23, 36, 547), + Trans(46, 24, 36, 547), + Trans(46, 25, 36, 547), + Trans(46, 26, 36, 547), + Trans(46, 28, 36, 547), + Trans(46, 29, 36, 547), + Trans(46, 34, 36, 547), + Trans(46, 40, 36, 547), + Trans(46, 41, 36, 547), + Trans(46, 45, 36, 547), + Trans(46, 47, 36, 547), + Trans(46, 51, 36, 547), + Trans(47, 5, 36, 547), + Trans(47, 16, 36, 547), + Trans(47, 17, 36, 547), + Trans(47, 18, 36, 547), + Trans(47, 19, 36, 547), + Trans(47, 20, 36, 547), + Trans(47, 21, 36, 547), + Trans(47, 22, 36, 547), + Trans(47, 23, 36, 547), + Trans(47, 24, 36, 547), + Trans(47, 25, 36, 547), + Trans(47, 26, 36, 547), + Trans(47, 39, 36, 547), + Trans(47, 47, 36, 547), + Trans(47, 51, 36, 547), + Trans(48, 5, 36, 547), + Trans(48, 16, 36, 547), + Trans(48, 17, 36, 547), + Trans(48, 18, 36, 547), + Trans(48, 19, 36, 547), + Trans(48, 20, 36, 547), + Trans(48, 21, 36, 547), + Trans(48, 22, 36, 547), + Trans(48, 23, 36, 547), + Trans(48, 24, 36, 547), + Trans(48, 25, 36, 547), + Trans(48, 26, 36, 547), + Trans(48, 29, 36, 547), + Trans(48, 34, 36, 547), + Trans(48, 39, 36, 547), + Trans(48, 40, 36, 547), + Trans(48, 41, 36, 547), + Trans(48, 47, 36, 547), + Trans(48, 51, 36, 547), + Trans(49, 5, 36, 547), + Trans(49, 16, 36, 547), + Trans(49, 17, 36, 547), + Trans(49, 18, 36, 547), + Trans(49, 19, 36, 547), + Trans(49, 20, 36, 547), + Trans(49, 21, 36, 547), + Trans(49, 22, 36, 547), + Trans(49, 23, 36, 547), + Trans(49, 24, 36, 547), + Trans(49, 25, 36, 547), + Trans(49, 26, 36, 547), + Trans(49, 28, 36, 547), + Trans(49, 29, 36, 547), + Trans(49, 34, 36, 547), + Trans(49, 39, 36, 547), + Trans(49, 40, 36, 547), + Trans(49, 41, 36, 547), + Trans(49, 47, 36, 547), + Trans(49, 51, 36, 547), + Trans(50, 5, 36, 547), + Trans(50, 16, 36, 547), + Trans(50, 17, 36, 547), + Trans(50, 18, 36, 547), + Trans(50, 19, 36, 547), + Trans(50, 20, 36, 547), + Trans(50, 21, 36, 547), + Trans(50, 22, 36, 547), + Trans(50, 23, 36, 547), + Trans(50, 24, 36, 547), + Trans(50, 25, 36, 547), + Trans(50, 26, 36, 547), + Trans(50, 46, 36, 547), + Trans(50, 47, 36, 547), + Trans(50, 51, 36, 547), + Trans(51, 5, 36, 547), + Trans(51, 16, 36, 547), + Trans(51, 17, 36, 547), + Trans(51, 18, 36, 547), + Trans(51, 19, 36, 547), + Trans(51, 20, 36, 547), + Trans(51, 21, 36, 547), + Trans(51, 22, 36, 547), + Trans(51, 23, 36, 547), + Trans(51, 24, 36, 547), + Trans(51, 25, 36, 547), + Trans(51, 26, 36, 547), + Trans(51, 29, 36, 547), + Trans(51, 34, 36, 547), + Trans(51, 40, 36, 547), + Trans(51, 41, 36, 547), + Trans(51, 46, 36, 547), + Trans(51, 47, 36, 547), + Trans(51, 51, 36, 547), + Trans(52, 5, 36, 547), + Trans(52, 16, 36, 547), + Trans(52, 17, 36, 547), + Trans(52, 18, 36, 547), + Trans(52, 19, 36, 547), + Trans(52, 20, 36, 547), + Trans(52, 21, 36, 547), + Trans(52, 22, 36, 547), + Trans(52, 23, 36, 547), + Trans(52, 24, 36, 547), + Trans(52, 25, 36, 547), + Trans(52, 26, 36, 547), + Trans(52, 28, 36, 547), + Trans(52, 29, 36, 547), + Trans(52, 34, 36, 547), + Trans(52, 40, 36, 547), + Trans(52, 41, 36, 547), + Trans(52, 46, 36, 547), + Trans(52, 47, 36, 547), + Trans(52, 51, 36, 547), + Trans(53, 15, 36, 547), + Trans(53, 16, 36, 547), + Trans(53, 17, 36, 547), + Trans(53, 18, 36, 547), + Trans(53, 19, 36, 547), + Trans(53, 20, 36, 547), + Trans(53, 21, 36, 547), + Trans(53, 22, 36, 547), + Trans(53, 23, 36, 547), + Trans(53, 24, 36, 547), + Trans(53, 25, 36, 547), + Trans(53, 26, 36, 547), + Trans(53, 29, 36, 547), + Trans(53, 30, 36, 547), + Trans(53, 31, 36, 547), + Trans(53, 34, 36, 547), + Trans(53, 35, 36, 547), + Trans(53, 40, 36, 547), + Trans(53, 41, 36, 547), + Trans(53, 47, 36, 547), + Trans(53, 51, 36, 547), + Trans(54, 5, 36, 547), + Trans(54, 39, 36, 547), + Trans(54, 53, 36, 547), + Trans(54, 65, 36, 547), + Trans(54, 69, 36, 547), + Trans(54, 70, 36, 547), + Trans(54, 80, 36, 547), + Trans(54, 99, 36, 547), + Trans(54, 100, 36, 547), + Trans(54, 111, 36, 547), + Trans(54, 112, 36, 547), + Trans(55, 5, 36, 547), + Trans(55, 6, 36, 547), + Trans(55, 7, 36, 547), + Trans(55, 8, 36, 547), + Trans(55, 9, 36, 547), + Trans(55, 10, 36, 547), + Trans(55, 11, 36, 547), + Trans(55, 18, 36, 547), + Trans(55, 24, 36, 547), + Trans(55, 25, 36, 547), + Trans(55, 26, 36, 547), + Trans(55, 27, 36, 547), + Trans(55, 38, 36, 547), + Trans(55, 39, 36, 547), + Trans(55, 41, 36, 547), + Trans(55, 45, 36, 547), + Trans(55, 53, 36, 547), + Trans(55, 70, 36, 547), + Trans(55, 76, 36, 547), + Trans(55, 83, 36, 547), + Trans(55, 86, 36, 547), + Trans(55, 88, 36, 547), + Trans(55, 111, 36, 547), + Trans(55, 112, 36, 547), + Trans(56, 15, 36, 547), + Trans(56, 16, 36, 547), + Trans(56, 17, 36, 547), + Trans(56, 18, 36, 547), + Trans(56, 19, 36, 547), + Trans(56, 20, 36, 547), + Trans(56, 21, 36, 547), + Trans(56, 22, 36, 547), + Trans(56, 23, 36, 547), + Trans(56, 24, 36, 547), + Trans(56, 25, 36, 547), + Trans(56, 26, 36, 547), + Trans(56, 28, 36, 547), + Trans(56, 29, 36, 547), + Trans(56, 30, 36, 547), + Trans(56, 31, 36, 547), + Trans(56, 34, 36, 547), + Trans(56, 35, 36, 547), + Trans(56, 40, 36, 547), + Trans(56, 41, 36, 547), + Trans(56, 47, 36, 547), + Trans(56, 51, 36, 547), + Trans(57, 5, 36, 547), + Trans(57, 7, 36, 547), + Trans(57, 8, 36, 547), + Trans(57, 9, 36, 547), + Trans(57, 10, 36, 547), + Trans(57, 11, 36, 547), + Trans(57, 111, 36, 547), + Trans(57, 112, 36, 547), + Trans(58, 16, 36, 547), + Trans(58, 17, 36, 547), + Trans(58, 18, 36, 547), + Trans(58, 19, 36, 547), + Trans(58, 20, 36, 547), + Trans(58, 21, 36, 547), + Trans(58, 22, 36, 547), + Trans(58, 23, 36, 547), + Trans(58, 24, 36, 547), + Trans(58, 25, 36, 547), + Trans(58, 26, 36, 547), + Trans(58, 30, 36, 547), + Trans(58, 31, 36, 547), + Trans(58, 47, 36, 547), + Trans(58, 51, 36, 547), + Trans(59, 30, 36, 547), + Trans(60, 5, 36, 547), + Trans(60, 43, 36, 547), + Trans(60, 53, 36, 547), + Trans(60, 65, 36, 547), + Trans(60, 69, 36, 547), + Trans(60, 70, 36, 547), + Trans(60, 80, 36, 547), + Trans(60, 99, 36, 547), + Trans(60, 100, 36, 547), + Trans(60, 111, 36, 547), + Trans(60, 112, 36, 547), + Trans(61, 39, 36, 547), + Trans(62, 46, 36, 547), + Trans(63, 5, 36, 547), + Trans(63, 43, 36, 547), + Trans(63, 53, 36, 547), + Trans(63, 65, 36, 547), + Trans(63, 69, 36, 547), + Trans(63, 70, 36, 547), + Trans(63, 80, 36, 547), + Trans(63, 99, 36, 547), + Trans(63, 100, 36, 547), + Trans(63, 110, 36, 547), + Trans(63, 111, 36, 547), + Trans(63, 112, 36, 547), + Trans(64, 112, 36, 547), ], k: 3, }, - /* 251 - "IfResetStatementList0List" */ + /* 255 - "IfResetStatementList0List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 539), - Trans(0, 52, 1, 538), - Trans(0, 64, 1, 538), - Trans(0, 68, 1, 538), - Trans(0, 69, 1, 538), - Trans(0, 79, 1, 538), - Trans(0, 98, 1, 538), - Trans(0, 99, 1, 538), - Trans(0, 110, 1, 538), - Trans(0, 111, 1, 538), + Trans(0, 43, 2, 546), + Trans(0, 53, 1, 545), + Trans(0, 65, 1, 545), + Trans(0, 69, 1, 545), + Trans(0, 70, 1, 545), + Trans(0, 80, 1, 545), + Trans(0, 99, 1, 545), + Trans(0, 100, 1, 545), + Trans(0, 111, 1, 545), + Trans(0, 112, 1, 545), ], k: 1, }, - /* 252 - "IfResetStatementOpt" */ + /* 256 - "IfResetStatementOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 2, 546), - Trans(0, 7, 2, 546), - Trans(0, 8, 2, 546), - Trans(0, 9, 2, 546), - Trans(0, 10, 2, 546), - Trans(0, 11, 2, 546), - Trans(0, 18, 2, 546), - Trans(0, 24, 2, 546), - Trans(0, 25, 2, 546), - Trans(0, 26, 2, 546), - Trans(0, 27, 2, 546), - Trans(0, 37, 2, 546), - Trans(0, 38, 2, 546), - Trans(0, 40, 2, 546), - Trans(0, 42, 2, 546), - Trans(0, 52, 2, 546), - Trans(0, 56, 2, 546), - Trans(0, 57, 1, 543), - Trans(0, 64, 2, 546), - Trans(0, 68, 2, 546), - Trans(0, 69, 2, 546), - Trans(0, 75, 2, 546), - Trans(0, 79, 2, 546), - Trans(0, 82, 2, 546), - Trans(0, 85, 2, 546), - Trans(0, 87, 2, 546), - Trans(0, 98, 2, 546), - Trans(0, 99, 2, 546), - Trans(0, 109, 2, 546), - Trans(0, 110, 2, 546), - Trans(0, 111, 2, 546), + Trans(0, 6, 2, 553), + Trans(0, 7, 2, 553), + Trans(0, 8, 2, 553), + Trans(0, 9, 2, 553), + Trans(0, 10, 2, 553), + Trans(0, 11, 2, 553), + Trans(0, 18, 2, 553), + Trans(0, 24, 2, 553), + Trans(0, 25, 2, 553), + Trans(0, 26, 2, 553), + Trans(0, 27, 2, 553), + Trans(0, 38, 2, 553), + Trans(0, 39, 2, 553), + Trans(0, 41, 2, 553), + Trans(0, 43, 2, 553), + Trans(0, 53, 2, 553), + Trans(0, 57, 2, 553), + Trans(0, 58, 1, 550), + Trans(0, 65, 2, 553), + Trans(0, 69, 2, 553), + Trans(0, 70, 2, 553), + Trans(0, 76, 2, 553), + Trans(0, 80, 2, 553), + Trans(0, 83, 2, 553), + Trans(0, 86, 2, 553), + Trans(0, 88, 2, 553), + Trans(0, 99, 2, 553), + Trans(0, 100, 2, 553), + Trans(0, 110, 2, 553), + Trans(0, 111, 2, 553), + Trans(0, 112, 2, 553), ], k: 1, }, - /* 253 - "IfResetStatementOptList" */ + /* 257 - "IfResetStatementOptList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 545), - Trans(0, 52, 1, 544), - Trans(0, 64, 1, 544), - Trans(0, 68, 1, 544), - Trans(0, 69, 1, 544), - Trans(0, 79, 1, 544), - Trans(0, 98, 1, 544), - Trans(0, 99, 1, 544), - Trans(0, 110, 1, 544), - Trans(0, 111, 1, 544), + Trans(0, 43, 2, 552), + Trans(0, 53, 1, 551), + Trans(0, 65, 1, 551), + Trans(0, 69, 1, 551), + Trans(0, 70, 1, 551), + Trans(0, 80, 1, 551), + Trans(0, 99, 1, 551), + Trans(0, 100, 1, 551), + Trans(0, 111, 1, 551), + Trans(0, 112, 1, 551), ], k: 1, }, - /* 254 - "IfResetTerm" */ + /* 258 - "IfResetTerm" */ LookaheadDFA { - prod0: 63, + prod0: 64, transitions: &[], k: 0, }, - /* 255 - "IfResetToken" */ + /* 259 - "IfResetToken" */ LookaheadDFA { - prod0: 174, + prod0: 176, transitions: &[], k: 0, }, - /* 256 - "IfStatement" */ + /* 260 - "IfStatement" */ LookaheadDFA { - prod0: 525, + prod0: 532, transitions: &[], k: 0, }, - /* 257 - "IfStatementList" */ + /* 261 - "IfStatementList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 531), - Trans(0, 52, 1, 530), - Trans(0, 64, 1, 530), - Trans(0, 68, 1, 530), - Trans(0, 69, 1, 530), - Trans(0, 79, 1, 530), - Trans(0, 98, 1, 530), - Trans(0, 99, 1, 530), - Trans(0, 110, 1, 530), - Trans(0, 111, 1, 530), + Trans(0, 43, 2, 538), + Trans(0, 53, 1, 537), + Trans(0, 65, 1, 537), + Trans(0, 69, 1, 537), + Trans(0, 70, 1, 537), + Trans(0, 80, 1, 537), + Trans(0, 99, 1, 537), + Trans(0, 100, 1, 537), + Trans(0, 111, 1, 537), + Trans(0, 112, 1, 537), ], k: 1, }, - /* 258 - "IfStatementList0" */ + /* 262 - "IfStatementList0" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -6340,4117 +6749,4383 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(0, 25, 6, -1), Trans(0, 26, 6, -1), Trans(0, 27, 6, -1), - Trans(0, 37, 7, -1), - Trans(0, 38, 8, -1), - Trans(0, 40, 9, -1), - Trans(0, 42, 10, -1), - Trans(0, 52, 11, -1), - Trans(0, 56, 12, -1), - Trans(0, 57, 1, -1), - Trans(0, 64, 13, -1), - Trans(0, 68, 14, -1), - Trans(0, 69, 11, -1), - Trans(0, 75, 11, -1), - Trans(0, 79, 13, -1), - Trans(0, 82, 5, -1), - Trans(0, 85, 5, -1), - Trans(0, 87, 11, -1), - Trans(0, 98, 15, -1), - Trans(0, 99, 16, -1), - Trans(0, 109, 13, -1), - Trans(0, 110, 17, -1), + Trans(0, 38, 7, -1), + Trans(0, 39, 8, -1), + Trans(0, 41, 9, -1), + Trans(0, 43, 10, -1), + Trans(0, 53, 11, -1), + Trans(0, 57, 12, -1), + Trans(0, 58, 1, -1), + Trans(0, 65, 13, -1), + Trans(0, 69, 14, -1), + Trans(0, 70, 11, -1), + Trans(0, 76, 11, -1), + Trans(0, 80, 13, -1), + Trans(0, 83, 5, -1), + Trans(0, 86, 5, -1), + Trans(0, 88, 11, -1), + Trans(0, 99, 15, -1), + Trans(0, 100, 16, -1), + Trans(0, 110, 13, -1), Trans(0, 111, 17, -1), + Trans(0, 112, 18, -1), Trans(1, 5, 4, -1), - Trans(1, 38, 51, -1), - Trans(1, 69, 2, -1), - Trans(2, 5, 3, 526), - Trans(2, 6, 3, 526), - Trans(2, 7, 3, 526), - Trans(2, 8, 3, 526), - Trans(2, 9, 3, 526), - Trans(2, 10, 3, 526), - Trans(2, 11, 3, 526), - Trans(2, 18, 3, 526), - Trans(2, 24, 3, 526), - Trans(2, 25, 3, 526), - Trans(2, 26, 3, 526), - Trans(2, 27, 3, 526), - Trans(2, 37, 3, 526), - Trans(2, 38, 3, 526), - Trans(2, 40, 3, 526), - Trans(2, 52, 3, 526), - Trans(2, 69, 3, 526), - Trans(2, 75, 3, 526), - Trans(2, 82, 3, 526), - Trans(2, 85, 3, 526), - Trans(2, 87, 3, 526), - Trans(2, 110, 3, 526), - Trans(2, 111, 3, 526), - Trans(4, 38, 34, 529), - Trans(4, 69, 3, 526), - Trans(5, 5, 49, -1), - Trans(5, 16, 20, -1), - Trans(5, 17, 20, -1), - Trans(5, 18, 20, -1), - Trans(5, 19, 20, -1), - Trans(5, 20, 20, -1), - Trans(5, 21, 20, -1), - Trans(5, 22, 20, -1), - Trans(5, 23, 20, -1), - Trans(5, 24, 20, -1), - Trans(5, 25, 20, -1), - Trans(5, 26, 20, -1), - Trans(5, 29, 47, -1), - Trans(5, 30, 20, -1), - Trans(5, 46, 20, -1), - Trans(5, 50, 31, -1), - Trans(6, 5, 35, -1), - Trans(6, 6, 19, -1), - Trans(6, 7, 19, -1), - Trans(6, 8, 19, -1), - Trans(6, 9, 19, -1), - Trans(6, 10, 19, -1), - Trans(6, 11, 19, -1), - Trans(6, 18, 20, -1), - Trans(6, 24, 20, -1), - Trans(6, 25, 20, -1), - Trans(6, 26, 20, -1), - Trans(6, 27, 20, -1), - Trans(6, 37, 23, -1), - Trans(6, 38, 20, -1), - Trans(6, 40, 20, -1), - Trans(6, 52, 20, -1), - Trans(6, 69, 20, -1), - Trans(6, 75, 20, -1), - Trans(6, 82, 19, -1), - Trans(6, 85, 19, -1), - Trans(6, 87, 20, -1), - Trans(6, 110, 36, -1), - Trans(6, 111, 36, -1), - Trans(7, 5, 37, -1), - Trans(7, 6, 38, -1), - Trans(7, 7, 38, -1), - Trans(7, 8, 38, -1), - Trans(7, 9, 38, -1), - Trans(7, 10, 38, -1), - Trans(7, 11, 38, -1), - Trans(7, 18, 20, -1), - Trans(7, 24, 20, -1), - Trans(7, 25, 20, -1), - Trans(7, 26, 20, -1), - Trans(7, 27, 20, -1), - Trans(7, 37, 23, -1), - Trans(7, 38, 20, -1), - Trans(7, 40, 20, -1), - Trans(7, 52, 20, -1), - Trans(7, 56, 28, -1), - Trans(7, 69, 20, -1), - Trans(7, 75, 20, -1), - Trans(7, 82, 38, -1), - Trans(7, 85, 38, -1), - Trans(7, 87, 20, -1), - Trans(7, 110, 39, -1), - Trans(7, 111, 39, -1), - Trans(8, 5, 35, -1), - Trans(8, 6, 38, -1), - Trans(8, 7, 38, -1), - Trans(8, 8, 38, -1), - Trans(8, 9, 38, -1), - Trans(8, 10, 38, -1), - Trans(8, 11, 38, -1), - Trans(8, 18, 20, -1), - Trans(8, 24, 20, -1), - Trans(8, 25, 20, -1), - Trans(8, 26, 20, -1), - Trans(8, 27, 20, -1), - Trans(8, 37, 23, -1), - Trans(8, 38, 20, -1), - Trans(8, 40, 20, -1), - Trans(8, 52, 20, -1), - Trans(8, 69, 20, -1), - Trans(8, 75, 20, -1), - Trans(8, 82, 38, -1), - Trans(8, 85, 38, -1), - Trans(8, 87, 20, -1), - Trans(8, 110, 39, -1), - Trans(8, 111, 39, -1), - Trans(9, 5, 35, -1), - Trans(9, 6, 40, -1), - Trans(9, 7, 40, -1), - Trans(9, 8, 40, -1), - Trans(9, 9, 40, -1), - Trans(9, 10, 40, -1), - Trans(9, 11, 40, -1), - Trans(9, 18, 20, -1), - Trans(9, 24, 20, -1), - Trans(9, 25, 20, -1), - Trans(9, 26, 20, -1), - Trans(9, 27, 20, -1), - Trans(9, 37, 23, -1), - Trans(9, 38, 20, -1), - Trans(9, 40, 20, -1), - Trans(9, 52, 20, -1), - Trans(9, 69, 20, -1), - Trans(9, 75, 20, -1), - Trans(9, 82, 40, -1), - Trans(9, 85, 40, -1), - Trans(9, 87, 20, -1), - Trans(9, 110, 41, -1), - Trans(9, 111, 41, -1), - Trans(10, 5, 18, -1), - Trans(10, 6, 19, -1), - Trans(10, 7, 19, -1), - Trans(10, 8, 19, -1), - Trans(10, 9, 19, -1), - Trans(10, 10, 19, -1), - Trans(10, 11, 19, -1), - Trans(10, 18, 20, -1), - Trans(10, 24, 20, -1), - Trans(10, 25, 20, -1), - Trans(10, 26, 20, -1), - Trans(10, 27, 20, -1), - Trans(10, 29, 21, -1), - Trans(10, 35, 22, -1), - Trans(10, 37, 23, -1), + Trans(1, 39, 60, -1), + Trans(1, 70, 2, -1), + Trans(2, 5, 3, 533), + Trans(2, 6, 3, 533), + Trans(2, 7, 3, 533), + Trans(2, 8, 3, 533), + Trans(2, 9, 3, 533), + Trans(2, 10, 3, 533), + Trans(2, 11, 3, 533), + Trans(2, 18, 3, 533), + Trans(2, 24, 3, 533), + Trans(2, 25, 3, 533), + Trans(2, 26, 3, 533), + Trans(2, 27, 3, 533), + Trans(2, 38, 3, 533), + Trans(2, 39, 3, 533), + Trans(2, 41, 3, 533), + Trans(2, 53, 3, 533), + Trans(2, 70, 3, 533), + Trans(2, 76, 3, 533), + Trans(2, 83, 3, 533), + Trans(2, 86, 3, 533), + Trans(2, 88, 3, 533), + Trans(2, 111, 3, 533), + Trans(2, 112, 3, 533), + Trans(4, 39, 36, 536), + Trans(4, 70, 3, 533), + Trans(5, 5, 58, -1), + Trans(5, 16, 21, -1), + Trans(5, 17, 21, -1), + Trans(5, 18, 21, -1), + Trans(5, 19, 21, -1), + Trans(5, 20, 21, -1), + Trans(5, 21, 21, -1), + Trans(5, 22, 21, -1), + Trans(5, 23, 21, -1), + Trans(5, 24, 21, -1), + Trans(5, 25, 21, -1), + Trans(5, 26, 21, -1), + Trans(5, 30, 54, -1), + Trans(5, 31, 21, -1), + Trans(5, 47, 21, -1), + Trans(5, 51, 32, -1), + Trans(6, 5, 37, -1), + Trans(6, 6, 20, -1), + Trans(6, 7, 20, -1), + Trans(6, 8, 20, -1), + Trans(6, 9, 20, -1), + Trans(6, 10, 20, -1), + Trans(6, 11, 20, -1), + Trans(6, 18, 21, -1), + Trans(6, 24, 21, -1), + Trans(6, 25, 21, -1), + Trans(6, 26, 21, -1), + Trans(6, 27, 21, -1), + Trans(6, 38, 24, -1), + Trans(6, 39, 21, -1), + Trans(6, 41, 21, -1), + Trans(6, 53, 21, -1), + Trans(6, 70, 21, -1), + Trans(6, 76, 21, -1), + Trans(6, 83, 20, -1), + Trans(6, 86, 20, -1), + Trans(6, 88, 21, -1), + Trans(6, 111, 38, -1), + Trans(6, 112, 39, -1), + Trans(7, 5, 40, -1), + Trans(7, 6, 41, -1), + Trans(7, 7, 41, -1), + Trans(7, 8, 41, -1), + Trans(7, 9, 41, -1), + Trans(7, 10, 41, -1), + Trans(7, 11, 41, -1), + Trans(7, 18, 21, -1), + Trans(7, 24, 21, -1), + Trans(7, 25, 21, -1), + Trans(7, 26, 21, -1), + Trans(7, 27, 21, -1), + Trans(7, 38, 24, -1), + Trans(7, 39, 21, -1), + Trans(7, 41, 21, -1), + Trans(7, 53, 21, -1), + Trans(7, 57, 29, -1), + Trans(7, 70, 21, -1), + Trans(7, 76, 21, -1), + Trans(7, 83, 41, -1), + Trans(7, 86, 41, -1), + Trans(7, 88, 21, -1), + Trans(7, 111, 42, -1), + Trans(7, 112, 43, -1), + Trans(8, 5, 37, -1), + Trans(8, 6, 41, -1), + Trans(8, 7, 41, -1), + Trans(8, 8, 41, -1), + Trans(8, 9, 41, -1), + Trans(8, 10, 41, -1), + Trans(8, 11, 41, -1), + Trans(8, 18, 21, -1), + Trans(8, 24, 21, -1), + Trans(8, 25, 21, -1), + Trans(8, 26, 21, -1), + Trans(8, 27, 21, -1), + Trans(8, 38, 24, -1), + Trans(8, 39, 21, -1), + Trans(8, 41, 21, -1), + Trans(8, 53, 21, -1), + Trans(8, 70, 21, -1), + Trans(8, 76, 21, -1), + Trans(8, 83, 41, -1), + Trans(8, 86, 41, -1), + Trans(8, 88, 21, -1), + Trans(8, 111, 42, -1), + Trans(8, 112, 43, -1), + Trans(9, 5, 37, -1), + Trans(9, 6, 44, -1), + Trans(9, 7, 44, -1), + Trans(9, 8, 44, -1), + Trans(9, 9, 44, -1), + Trans(9, 10, 44, -1), + Trans(9, 11, 44, -1), + Trans(9, 18, 21, -1), + Trans(9, 24, 21, -1), + Trans(9, 25, 21, -1), + Trans(9, 26, 21, -1), + Trans(9, 27, 21, -1), + Trans(9, 38, 24, -1), + Trans(9, 39, 21, -1), + Trans(9, 41, 21, -1), + Trans(9, 53, 21, -1), + Trans(9, 70, 21, -1), + Trans(9, 76, 21, -1), + Trans(9, 83, 44, -1), + Trans(9, 86, 44, -1), + Trans(9, 88, 21, -1), + Trans(9, 111, 45, -1), + Trans(9, 112, 46, -1), + Trans(10, 5, 19, -1), + Trans(10, 6, 20, -1), + Trans(10, 7, 20, -1), + Trans(10, 8, 20, -1), + Trans(10, 9, 20, -1), + Trans(10, 10, 20, -1), + Trans(10, 11, 20, -1), + Trans(10, 18, 21, -1), + Trans(10, 24, 21, -1), + Trans(10, 25, 21, -1), + Trans(10, 26, 21, -1), + Trans(10, 27, 21, -1), + Trans(10, 30, 22, -1), + Trans(10, 36, 23, -1), Trans(10, 38, 24, -1), - Trans(10, 40, 20, -1), - Trans(10, 42, 25, -1), - Trans(10, 47, 26, -1), + Trans(10, 39, 25, -1), + Trans(10, 41, 21, -1), + Trans(10, 43, 26, -1), Trans(10, 48, 27, -1), - Trans(10, 49, 21, -1), - Trans(10, 52, 20, -1), - Trans(10, 56, 28, -1), + Trans(10, 49, 28, -1), + Trans(10, 50, 22, -1), + Trans(10, 53, 21, -1), Trans(10, 57, 29, -1), - Trans(10, 59, 21, -1), - Trans(10, 60, 30, -1), - Trans(10, 63, 26, -1), - Trans(10, 64, 21, -1), - Trans(10, 65, 21, -1), - Trans(10, 68, 26, -1), - Trans(10, 69, 20, -1), - Trans(10, 70, 31, -1), - Trans(10, 72, 26, -1), - Trans(10, 75, 20, -1), + Trans(10, 58, 30, -1), + Trans(10, 60, 22, -1), + Trans(10, 61, 31, -1), + Trans(10, 64, 27, -1), + Trans(10, 65, 22, -1), + Trans(10, 66, 22, -1), + Trans(10, 69, 27, -1), + Trans(10, 70, 21, -1), + Trans(10, 71, 32, -1), + Trans(10, 73, 27, -1), Trans(10, 76, 21, -1), - Trans(10, 79, 21, -1), - Trans(10, 80, 21, -1), - Trans(10, 82, 19, -1), - Trans(10, 83, 21, -1), - Trans(10, 85, 19, -1), - Trans(10, 87, 20, -1), - Trans(10, 98, 20, -1), - Trans(10, 99, 32, -1), - Trans(10, 103, 21, -1), - Trans(10, 105, 21, -1), - Trans(10, 108, 21, -1), - Trans(10, 109, 21, -1), - Trans(10, 110, 33, -1), - Trans(10, 111, 33, -1), - Trans(11, 5, 35, -1), - Trans(11, 6, 42, -1), - Trans(11, 7, 42, -1), - Trans(11, 8, 42, -1), - Trans(11, 9, 42, -1), - Trans(11, 10, 42, -1), - Trans(11, 11, 42, -1), - Trans(11, 18, 20, -1), - Trans(11, 24, 20, -1), - Trans(11, 25, 20, -1), - Trans(11, 26, 20, -1), - Trans(11, 27, 20, -1), - Trans(11, 37, 23, -1), - Trans(11, 38, 20, -1), - Trans(11, 40, 20, -1), - Trans(11, 52, 20, -1), - Trans(11, 69, 20, -1), - Trans(11, 75, 20, -1), - Trans(11, 82, 42, -1), - Trans(11, 85, 42, -1), - Trans(11, 87, 20, -1), - Trans(11, 110, 43, -1), - Trans(11, 111, 43, -1), - Trans(12, 5, 50, -1), - Trans(12, 29, 47, -1), - Trans(13, 5, 55, -1), - Trans(13, 111, 28, -1), - Trans(14, 5, 52, -1), - Trans(14, 38, 51, -1), - Trans(15, 5, 35, -1), - Trans(15, 6, 44, -1), - Trans(15, 7, 44, -1), - Trans(15, 8, 44, -1), - Trans(15, 9, 44, -1), - Trans(15, 10, 44, -1), - Trans(15, 11, 44, -1), - Trans(15, 18, 20, -1), - Trans(15, 24, 20, -1), - Trans(15, 25, 20, -1), - Trans(15, 26, 20, -1), - Trans(15, 27, 20, -1), - Trans(15, 37, 23, -1), - Trans(15, 38, 20, -1), - Trans(15, 40, 20, -1), - Trans(15, 52, 20, -1), - Trans(15, 69, 20, -1), - Trans(15, 75, 20, -1), - Trans(15, 82, 44, -1), - Trans(15, 85, 44, -1), - Trans(15, 87, 20, -1), - Trans(15, 110, 45, -1), - Trans(15, 111, 45, -1), - Trans(16, 5, 53, -1), - Trans(16, 45, 54, -1), - Trans(17, 5, 46, -1), - Trans(17, 15, 20, -1), - Trans(17, 16, 20, -1), - Trans(17, 17, 20, -1), - Trans(17, 18, 20, -1), - Trans(17, 19, 20, -1), - Trans(17, 20, 20, -1), - Trans(17, 21, 20, -1), - Trans(17, 22, 20, -1), - Trans(17, 23, 20, -1), - Trans(17, 24, 20, -1), - Trans(17, 25, 20, -1), - Trans(17, 26, 20, -1), - Trans(17, 28, 21, -1), - Trans(17, 29, 47, -1), - Trans(17, 30, 20, -1), - Trans(17, 33, 21, -1), - Trans(17, 34, 20, -1), - Trans(17, 39, 20, -1), - Trans(17, 40, 48, -1), - Trans(17, 46, 20, -1), - Trans(17, 50, 31, -1), - Trans(18, 6, 34, 529), - Trans(18, 7, 34, 529), - Trans(18, 8, 34, 529), - Trans(18, 9, 34, 529), - Trans(18, 10, 34, 529), - Trans(18, 11, 34, 529), - Trans(18, 18, 34, 529), - Trans(18, 24, 34, 529), - Trans(18, 25, 34, 529), - Trans(18, 26, 34, 529), - Trans(18, 27, 34, 529), - Trans(18, 29, 34, 529), - Trans(18, 35, 34, 529), - Trans(18, 37, 34, 529), - Trans(18, 38, 34, 529), - Trans(18, 40, 34, 529), - Trans(18, 42, 34, 529), - Trans(18, 47, 34, 529), - Trans(18, 48, 34, 529), - Trans(18, 49, 34, 529), - Trans(18, 52, 34, 529), - Trans(18, 56, 34, 529), - Trans(18, 57, 34, 529), - Trans(18, 59, 34, 529), - Trans(18, 60, 34, 529), - Trans(18, 63, 34, 529), - Trans(18, 64, 34, 529), - Trans(18, 65, 34, 529), - Trans(18, 68, 34, 529), - Trans(18, 69, 34, 529), - Trans(18, 70, 34, 529), - Trans(18, 72, 34, 529), - Trans(18, 75, 34, 529), - Trans(18, 76, 34, 529), - Trans(18, 79, 34, 529), - Trans(18, 80, 34, 529), - Trans(18, 82, 34, 529), - Trans(18, 83, 34, 529), - Trans(18, 85, 34, 529), - Trans(18, 87, 34, 529), - Trans(18, 98, 34, 529), - Trans(18, 99, 34, 529), - Trans(18, 103, 34, 529), - Trans(18, 105, 34, 529), - Trans(18, 108, 34, 529), - Trans(18, 109, 34, 529), - Trans(18, 110, 34, 529), - Trans(18, 111, 34, 529), - Trans(19, 5, 34, 529), - Trans(19, 16, 34, 529), - Trans(19, 17, 34, 529), - Trans(19, 18, 34, 529), - Trans(19, 19, 34, 529), - Trans(19, 20, 34, 529), - Trans(19, 21, 34, 529), - Trans(19, 22, 34, 529), - Trans(19, 23, 34, 529), - Trans(19, 24, 34, 529), - Trans(19, 25, 34, 529), - Trans(19, 26, 34, 529), - Trans(19, 29, 34, 529), - Trans(19, 30, 34, 529), - Trans(19, 46, 34, 529), - Trans(19, 50, 34, 529), - Trans(20, 5, 34, 529), - Trans(20, 6, 34, 529), - Trans(20, 7, 34, 529), - Trans(20, 8, 34, 529), - Trans(20, 9, 34, 529), - Trans(20, 10, 34, 529), - Trans(20, 11, 34, 529), - Trans(20, 18, 34, 529), - Trans(20, 24, 34, 529), - Trans(20, 25, 34, 529), - Trans(20, 26, 34, 529), - Trans(20, 27, 34, 529), - Trans(20, 37, 34, 529), - Trans(20, 38, 34, 529), - Trans(20, 40, 34, 529), - Trans(20, 52, 34, 529), - Trans(20, 69, 34, 529), - Trans(20, 75, 34, 529), - Trans(20, 82, 34, 529), - Trans(20, 85, 34, 529), - Trans(20, 87, 34, 529), - Trans(20, 110, 34, 529), - Trans(20, 111, 34, 529), - Trans(21, 5, 34, 529), - Trans(21, 111, 34, 529), - Trans(22, 5, 34, 529), - Trans(22, 39, 34, 529), - Trans(23, 5, 34, 529), - Trans(23, 6, 34, 529), - Trans(23, 7, 34, 529), - Trans(23, 8, 34, 529), - Trans(23, 9, 34, 529), - Trans(23, 10, 34, 529), - Trans(23, 11, 34, 529), - Trans(23, 18, 34, 529), - Trans(23, 24, 34, 529), - Trans(23, 25, 34, 529), - Trans(23, 26, 34, 529), - Trans(23, 27, 34, 529), - Trans(23, 37, 34, 529), - Trans(23, 38, 34, 529), - Trans(23, 40, 34, 529), - Trans(23, 52, 34, 529), - Trans(23, 56, 34, 529), - Trans(23, 69, 34, 529), - Trans(23, 75, 34, 529), - Trans(23, 82, 34, 529), - Trans(23, 85, 34, 529), - Trans(23, 87, 34, 529), - Trans(23, 110, 34, 529), - Trans(23, 111, 34, 529), - Trans(24, 5, 34, 529), - Trans(24, 6, 34, 529), - Trans(24, 7, 34, 529), - Trans(24, 8, 34, 529), - Trans(24, 9, 34, 529), - Trans(24, 10, 34, 529), - Trans(24, 11, 34, 529), - Trans(24, 18, 34, 529), - Trans(24, 24, 34, 529), - Trans(24, 25, 34, 529), - Trans(24, 26, 34, 529), - Trans(24, 27, 34, 529), - Trans(24, 29, 34, 529), - Trans(24, 35, 34, 529), - Trans(24, 37, 34, 529), - Trans(24, 38, 34, 529), - Trans(24, 40, 34, 529), - Trans(24, 42, 34, 529), - Trans(24, 47, 34, 529), - Trans(24, 48, 34, 529), - Trans(24, 49, 34, 529), - Trans(24, 52, 34, 529), - Trans(24, 59, 34, 529), - Trans(24, 60, 34, 529), - Trans(24, 63, 34, 529), - Trans(24, 64, 34, 529), - Trans(24, 65, 34, 529), - Trans(24, 69, 34, 529), - Trans(24, 70, 34, 529), - Trans(24, 72, 34, 529), - Trans(24, 75, 34, 529), - Trans(24, 76, 34, 529), - Trans(24, 79, 34, 529), - Trans(24, 80, 34, 529), - Trans(24, 82, 34, 529), - Trans(24, 83, 34, 529), - Trans(24, 85, 34, 529), - Trans(24, 87, 34, 529), - Trans(24, 103, 34, 529), - Trans(24, 105, 34, 529), - Trans(24, 108, 34, 529), - Trans(24, 109, 34, 529), - Trans(24, 110, 34, 529), - Trans(24, 111, 34, 529), - Trans(25, 0, 34, 529), - Trans(25, 5, 34, 529), - Trans(25, 6, 34, 529), - Trans(25, 7, 34, 529), - Trans(25, 8, 34, 529), - Trans(25, 9, 34, 529), - Trans(25, 10, 34, 529), - Trans(25, 11, 34, 529), - Trans(25, 18, 34, 529), - Trans(25, 24, 34, 529), - Trans(25, 25, 34, 529), - Trans(25, 26, 34, 529), - Trans(25, 27, 34, 529), - Trans(25, 29, 34, 529), - Trans(25, 35, 34, 529), - Trans(25, 37, 34, 529), - Trans(25, 38, 34, 529), - Trans(25, 40, 34, 529), - Trans(25, 42, 34, 529), - Trans(25, 47, 34, 529), - Trans(25, 48, 34, 529), - Trans(25, 49, 34, 529), - Trans(25, 52, 34, 529), - Trans(25, 56, 34, 529), - Trans(25, 57, 34, 529), - Trans(25, 58, 34, 529), - Trans(25, 59, 34, 529), - Trans(25, 60, 34, 529), - Trans(25, 63, 34, 529), - Trans(25, 64, 34, 529), - Trans(25, 65, 34, 529), - Trans(25, 68, 34, 529), - Trans(25, 69, 34, 529), - Trans(25, 70, 34, 529), - Trans(25, 71, 34, 529), - Trans(25, 72, 34, 529), - Trans(25, 75, 34, 529), - Trans(25, 76, 34, 529), - Trans(25, 77, 34, 529), - Trans(25, 79, 34, 529), - Trans(25, 80, 34, 529), - Trans(25, 82, 34, 529), - Trans(25, 83, 34, 529), - Trans(25, 84, 34, 529), - Trans(25, 85, 34, 529), - Trans(25, 87, 34, 529), - Trans(25, 88, 34, 529), - Trans(25, 90, 34, 529), - Trans(25, 98, 34, 529), - Trans(25, 99, 34, 529), - Trans(25, 103, 34, 529), - Trans(25, 105, 34, 529), - Trans(25, 108, 34, 529), - Trans(25, 109, 34, 529), - Trans(25, 110, 34, 529), - Trans(25, 111, 34, 529), - Trans(26, 5, 34, 529), - Trans(26, 38, 34, 529), - Trans(27, 5, 34, 529), - Trans(27, 40, 34, 529), - Trans(28, 5, 34, 529), - Trans(28, 29, 34, 529), - Trans(29, 5, 34, 529), - Trans(29, 38, 34, 529), - Trans(29, 69, 34, 529), - Trans(30, 5, 34, 529), - Trans(30, 46, 34, 529), - Trans(30, 110, 34, 529), - Trans(30, 111, 34, 529), - Trans(31, 5, 34, 529), - Trans(31, 110, 34, 529), - Trans(31, 111, 34, 529), - Trans(32, 5, 34, 529), - Trans(32, 45, 34, 529), - Trans(33, 5, 34, 529), - Trans(33, 15, 34, 529), - Trans(33, 16, 34, 529), - Trans(33, 17, 34, 529), - Trans(33, 18, 34, 529), - Trans(33, 19, 34, 529), - Trans(33, 20, 34, 529), - Trans(33, 21, 34, 529), - Trans(33, 22, 34, 529), - Trans(33, 23, 34, 529), - Trans(33, 24, 34, 529), - Trans(33, 25, 34, 529), - Trans(33, 26, 34, 529), - Trans(33, 28, 34, 529), - Trans(33, 29, 34, 529), - Trans(33, 30, 34, 529), - Trans(33, 33, 34, 529), - Trans(33, 34, 34, 529), - Trans(33, 39, 34, 529), - Trans(33, 40, 34, 529), - Trans(33, 46, 34, 529), - Trans(33, 50, 34, 529), - Trans(35, 6, 34, 529), - Trans(35, 7, 34, 529), - Trans(35, 8, 34, 529), - Trans(35, 9, 34, 529), - Trans(35, 10, 34, 529), - Trans(35, 11, 34, 529), - Trans(35, 18, 34, 529), - Trans(35, 24, 34, 529), - Trans(35, 25, 34, 529), - Trans(35, 26, 34, 529), - Trans(35, 27, 34, 529), - Trans(35, 37, 34, 529), - Trans(35, 38, 34, 529), - Trans(35, 40, 34, 529), - Trans(35, 52, 34, 529), - Trans(35, 69, 34, 529), - Trans(35, 75, 34, 529), - Trans(35, 82, 34, 529), - Trans(35, 85, 34, 529), - Trans(35, 87, 34, 529), - Trans(35, 110, 34, 529), - Trans(35, 111, 34, 529), - Trans(36, 5, 34, 529), - Trans(36, 16, 34, 529), - Trans(36, 17, 34, 529), - Trans(36, 18, 34, 529), - Trans(36, 19, 34, 529), - Trans(36, 20, 34, 529), - Trans(36, 21, 34, 529), - Trans(36, 22, 34, 529), - Trans(36, 23, 34, 529), - Trans(36, 24, 34, 529), - Trans(36, 25, 34, 529), - Trans(36, 26, 34, 529), - Trans(36, 28, 34, 529), - Trans(36, 29, 34, 529), - Trans(36, 30, 34, 529), - Trans(36, 33, 34, 529), - Trans(36, 39, 34, 529), - Trans(36, 40, 34, 529), - Trans(36, 46, 34, 529), - Trans(36, 50, 34, 529), - Trans(37, 6, 34, 529), - Trans(37, 7, 34, 529), - Trans(37, 8, 34, 529), - Trans(37, 9, 34, 529), - Trans(37, 10, 34, 529), - Trans(37, 11, 34, 529), - Trans(37, 18, 34, 529), - Trans(37, 24, 34, 529), - Trans(37, 25, 34, 529), - Trans(37, 26, 34, 529), - Trans(37, 27, 34, 529), - Trans(37, 37, 34, 529), - Trans(37, 38, 34, 529), - Trans(37, 40, 34, 529), - Trans(37, 52, 34, 529), - Trans(37, 56, 34, 529), - Trans(37, 69, 34, 529), - Trans(37, 75, 34, 529), - Trans(37, 82, 34, 529), - Trans(37, 85, 34, 529), - Trans(37, 87, 34, 529), - Trans(37, 110, 34, 529), - Trans(37, 111, 34, 529), - Trans(38, 5, 34, 529), - Trans(38, 16, 34, 529), - Trans(38, 17, 34, 529), - Trans(38, 18, 34, 529), - Trans(38, 19, 34, 529), - Trans(38, 20, 34, 529), - Trans(38, 21, 34, 529), - Trans(38, 22, 34, 529), - Trans(38, 23, 34, 529), - Trans(38, 24, 34, 529), - Trans(38, 25, 34, 529), - Trans(38, 26, 34, 529), - Trans(38, 30, 34, 529), - Trans(38, 42, 34, 529), - Trans(38, 46, 34, 529), - Trans(38, 50, 34, 529), - Trans(38, 92, 34, 529), - Trans(39, 5, 34, 529), - Trans(39, 16, 34, 529), - Trans(39, 17, 34, 529), - Trans(39, 18, 34, 529), - Trans(39, 19, 34, 529), - Trans(39, 20, 34, 529), - Trans(39, 21, 34, 529), - Trans(39, 22, 34, 529), - Trans(39, 23, 34, 529), - Trans(39, 24, 34, 529), - Trans(39, 25, 34, 529), - Trans(39, 26, 34, 529), - Trans(39, 28, 34, 529), - Trans(39, 30, 34, 529), - Trans(39, 33, 34, 529), - Trans(39, 39, 34, 529), - Trans(39, 40, 34, 529), - Trans(39, 42, 34, 529), - Trans(39, 46, 34, 529), - Trans(39, 50, 34, 529), - Trans(39, 92, 34, 529), - Trans(40, 5, 34, 529), - Trans(40, 16, 34, 529), - Trans(40, 17, 34, 529), - Trans(40, 18, 34, 529), - Trans(40, 19, 34, 529), - Trans(40, 20, 34, 529), - Trans(40, 21, 34, 529), - Trans(40, 22, 34, 529), - Trans(40, 23, 34, 529), - Trans(40, 24, 34, 529), - Trans(40, 25, 34, 529), - Trans(40, 26, 34, 529), - Trans(40, 44, 34, 529), - Trans(40, 46, 34, 529), - Trans(40, 50, 34, 529), - Trans(41, 5, 34, 529), - Trans(41, 16, 34, 529), - Trans(41, 17, 34, 529), - Trans(41, 18, 34, 529), - Trans(41, 19, 34, 529), - Trans(41, 20, 34, 529), - Trans(41, 21, 34, 529), - Trans(41, 22, 34, 529), - Trans(41, 23, 34, 529), - Trans(41, 24, 34, 529), - Trans(41, 25, 34, 529), - Trans(41, 26, 34, 529), - Trans(41, 28, 34, 529), - Trans(41, 33, 34, 529), - Trans(41, 39, 34, 529), - Trans(41, 40, 34, 529), - Trans(41, 44, 34, 529), - Trans(41, 46, 34, 529), - Trans(41, 50, 34, 529), - Trans(42, 5, 34, 529), - Trans(42, 16, 34, 529), - Trans(42, 17, 34, 529), - Trans(42, 18, 34, 529), - Trans(42, 19, 34, 529), - Trans(42, 20, 34, 529), - Trans(42, 21, 34, 529), - Trans(42, 22, 34, 529), - Trans(42, 23, 34, 529), - Trans(42, 24, 34, 529), - Trans(42, 25, 34, 529), - Trans(42, 26, 34, 529), - Trans(42, 38, 34, 529), - Trans(42, 46, 34, 529), - Trans(42, 50, 34, 529), - Trans(43, 5, 34, 529), - Trans(43, 16, 34, 529), - Trans(43, 17, 34, 529), - Trans(43, 18, 34, 529), - Trans(43, 19, 34, 529), - Trans(43, 20, 34, 529), - Trans(43, 21, 34, 529), - Trans(43, 22, 34, 529), - Trans(43, 23, 34, 529), - Trans(43, 24, 34, 529), - Trans(43, 25, 34, 529), - Trans(43, 26, 34, 529), - Trans(43, 28, 34, 529), - Trans(43, 33, 34, 529), - Trans(43, 38, 34, 529), - Trans(43, 39, 34, 529), - Trans(43, 40, 34, 529), - Trans(43, 46, 34, 529), - Trans(43, 50, 34, 529), - Trans(44, 5, 34, 529), - Trans(44, 16, 34, 529), - Trans(44, 17, 34, 529), - Trans(44, 18, 34, 529), - Trans(44, 19, 34, 529), - Trans(44, 20, 34, 529), - Trans(44, 21, 34, 529), - Trans(44, 22, 34, 529), - Trans(44, 23, 34, 529), - Trans(44, 24, 34, 529), - Trans(44, 25, 34, 529), - Trans(44, 26, 34, 529), - Trans(44, 45, 34, 529), - Trans(44, 46, 34, 529), - Trans(44, 50, 34, 529), - Trans(45, 5, 34, 529), - Trans(45, 16, 34, 529), - Trans(45, 17, 34, 529), - Trans(45, 18, 34, 529), - Trans(45, 19, 34, 529), - Trans(45, 20, 34, 529), - Trans(45, 21, 34, 529), - Trans(45, 22, 34, 529), - Trans(45, 23, 34, 529), - Trans(45, 24, 34, 529), - Trans(45, 25, 34, 529), - Trans(45, 26, 34, 529), - Trans(45, 28, 34, 529), - Trans(45, 33, 34, 529), - Trans(45, 39, 34, 529), - Trans(45, 40, 34, 529), - Trans(45, 45, 34, 529), - Trans(45, 46, 34, 529), - Trans(45, 50, 34, 529), - Trans(46, 15, 34, 529), - Trans(46, 16, 34, 529), - Trans(46, 17, 34, 529), - Trans(46, 18, 34, 529), - Trans(46, 19, 34, 529), - Trans(46, 20, 34, 529), - Trans(46, 21, 34, 529), - Trans(46, 22, 34, 529), - Trans(46, 23, 34, 529), - Trans(46, 24, 34, 529), - Trans(46, 25, 34, 529), - Trans(46, 26, 34, 529), - Trans(46, 28, 34, 529), - Trans(46, 29, 34, 529), - Trans(46, 30, 34, 529), - Trans(46, 33, 34, 529), - Trans(46, 34, 34, 529), - Trans(46, 39, 34, 529), - Trans(46, 40, 34, 529), - Trans(46, 46, 34, 529), - Trans(46, 50, 34, 529), - Trans(47, 5, 34, 529), - Trans(47, 38, 34, 529), - Trans(47, 52, 34, 529), - Trans(47, 64, 34, 529), - Trans(47, 68, 34, 529), - Trans(47, 69, 34, 529), - Trans(47, 79, 34, 529), - Trans(47, 98, 34, 529), - Trans(47, 99, 34, 529), - Trans(47, 110, 34, 529), - Trans(47, 111, 34, 529), - Trans(48, 5, 34, 529), - Trans(48, 6, 34, 529), - Trans(48, 7, 34, 529), - Trans(48, 8, 34, 529), - Trans(48, 9, 34, 529), - Trans(48, 10, 34, 529), - Trans(48, 11, 34, 529), - Trans(48, 18, 34, 529), - Trans(48, 24, 34, 529), - Trans(48, 25, 34, 529), - Trans(48, 26, 34, 529), - Trans(48, 27, 34, 529), - Trans(48, 37, 34, 529), - Trans(48, 38, 34, 529), - Trans(48, 40, 34, 529), - Trans(48, 44, 34, 529), - Trans(48, 52, 34, 529), - Trans(48, 69, 34, 529), - Trans(48, 75, 34, 529), - Trans(48, 82, 34, 529), - Trans(48, 85, 34, 529), - Trans(48, 87, 34, 529), - Trans(48, 110, 34, 529), - Trans(48, 111, 34, 529), - Trans(49, 16, 34, 529), - Trans(49, 17, 34, 529), - Trans(49, 18, 34, 529), - Trans(49, 19, 34, 529), - Trans(49, 20, 34, 529), - Trans(49, 21, 34, 529), - Trans(49, 22, 34, 529), - Trans(49, 23, 34, 529), - Trans(49, 24, 34, 529), - Trans(49, 25, 34, 529), - Trans(49, 26, 34, 529), - Trans(49, 29, 34, 529), - Trans(49, 30, 34, 529), - Trans(49, 46, 34, 529), - Trans(49, 50, 34, 529), - Trans(50, 29, 34, 529), - Trans(51, 5, 34, 529), - Trans(51, 42, 34, 529), - Trans(51, 52, 34, 529), - Trans(51, 64, 34, 529), - Trans(51, 68, 34, 529), - Trans(51, 69, 34, 529), - Trans(51, 79, 34, 529), - Trans(51, 98, 34, 529), - Trans(51, 99, 34, 529), - Trans(51, 110, 34, 529), - Trans(51, 111, 34, 529), - Trans(52, 38, 34, 529), - Trans(53, 45, 34, 529), - Trans(54, 5, 34, 529), - Trans(54, 42, 34, 529), - Trans(54, 52, 34, 529), - Trans(54, 64, 34, 529), - Trans(54, 68, 34, 529), - Trans(54, 69, 34, 529), - Trans(54, 79, 34, 529), - Trans(54, 98, 34, 529), - Trans(54, 99, 34, 529), - Trans(54, 109, 34, 529), - Trans(54, 110, 34, 529), - Trans(54, 111, 34, 529), - Trans(55, 111, 34, 529), + Trans(10, 77, 22, -1), + Trans(10, 80, 22, -1), + Trans(10, 81, 22, -1), + Trans(10, 83, 20, -1), + Trans(10, 84, 22, -1), + Trans(10, 86, 20, -1), + Trans(10, 88, 21, -1), + Trans(10, 99, 21, -1), + Trans(10, 100, 33, -1), + Trans(10, 104, 22, -1), + Trans(10, 106, 22, -1), + Trans(10, 109, 22, -1), + Trans(10, 110, 22, -1), + Trans(10, 111, 34, -1), + Trans(10, 112, 35, -1), + Trans(11, 5, 37, -1), + Trans(11, 6, 47, -1), + Trans(11, 7, 47, -1), + Trans(11, 8, 47, -1), + Trans(11, 9, 47, -1), + Trans(11, 10, 47, -1), + Trans(11, 11, 47, -1), + Trans(11, 18, 21, -1), + Trans(11, 24, 21, -1), + Trans(11, 25, 21, -1), + Trans(11, 26, 21, -1), + Trans(11, 27, 21, -1), + Trans(11, 38, 24, -1), + Trans(11, 39, 21, -1), + Trans(11, 41, 21, -1), + Trans(11, 53, 21, -1), + Trans(11, 70, 21, -1), + Trans(11, 76, 21, -1), + Trans(11, 83, 47, -1), + Trans(11, 86, 47, -1), + Trans(11, 88, 21, -1), + Trans(11, 111, 48, -1), + Trans(11, 112, 49, -1), + Trans(12, 5, 59, -1), + Trans(12, 30, 54, -1), + Trans(13, 5, 64, -1), + Trans(13, 112, 29, -1), + Trans(14, 5, 61, -1), + Trans(14, 39, 60, -1), + Trans(15, 5, 37, -1), + Trans(15, 6, 50, -1), + Trans(15, 7, 50, -1), + Trans(15, 8, 50, -1), + Trans(15, 9, 50, -1), + Trans(15, 10, 50, -1), + Trans(15, 11, 50, -1), + Trans(15, 18, 21, -1), + Trans(15, 24, 21, -1), + Trans(15, 25, 21, -1), + Trans(15, 26, 21, -1), + Trans(15, 27, 21, -1), + Trans(15, 38, 24, -1), + Trans(15, 39, 21, -1), + Trans(15, 41, 21, -1), + Trans(15, 53, 21, -1), + Trans(15, 70, 21, -1), + Trans(15, 76, 21, -1), + Trans(15, 83, 50, -1), + Trans(15, 86, 50, -1), + Trans(15, 88, 21, -1), + Trans(15, 111, 51, -1), + Trans(15, 112, 52, -1), + Trans(16, 5, 62, -1), + Trans(16, 46, 63, -1), + Trans(17, 5, 53, -1), + Trans(17, 15, 21, -1), + Trans(17, 16, 21, -1), + Trans(17, 17, 21, -1), + Trans(17, 18, 21, -1), + Trans(17, 19, 21, -1), + Trans(17, 20, 21, -1), + Trans(17, 21, 21, -1), + Trans(17, 22, 21, -1), + Trans(17, 23, 21, -1), + Trans(17, 24, 21, -1), + Trans(17, 25, 21, -1), + Trans(17, 26, 21, -1), + Trans(17, 29, 22, -1), + Trans(17, 30, 54, -1), + Trans(17, 31, 21, -1), + Trans(17, 34, 22, -1), + Trans(17, 35, 21, -1), + Trans(17, 40, 21, -1), + Trans(17, 41, 55, -1), + Trans(17, 47, 21, -1), + Trans(17, 51, 32, -1), + Trans(18, 5, 56, -1), + Trans(18, 15, 21, -1), + Trans(18, 16, 21, -1), + Trans(18, 17, 21, -1), + Trans(18, 18, 21, -1), + Trans(18, 19, 21, -1), + Trans(18, 20, 21, -1), + Trans(18, 21, 21, -1), + Trans(18, 22, 21, -1), + Trans(18, 23, 21, -1), + Trans(18, 24, 21, -1), + Trans(18, 25, 21, -1), + Trans(18, 26, 21, -1), + Trans(18, 28, 57, -1), + Trans(18, 29, 22, -1), + Trans(18, 30, 54, -1), + Trans(18, 31, 21, -1), + Trans(18, 34, 22, -1), + Trans(18, 35, 21, -1), + Trans(18, 40, 21, -1), + Trans(18, 41, 55, -1), + Trans(18, 47, 21, -1), + Trans(18, 51, 32, -1), + Trans(19, 6, 36, 536), + Trans(19, 7, 36, 536), + Trans(19, 8, 36, 536), + Trans(19, 9, 36, 536), + Trans(19, 10, 36, 536), + Trans(19, 11, 36, 536), + Trans(19, 18, 36, 536), + Trans(19, 24, 36, 536), + Trans(19, 25, 36, 536), + Trans(19, 26, 36, 536), + Trans(19, 27, 36, 536), + Trans(19, 30, 36, 536), + Trans(19, 36, 36, 536), + Trans(19, 38, 36, 536), + Trans(19, 39, 36, 536), + Trans(19, 41, 36, 536), + Trans(19, 43, 36, 536), + Trans(19, 48, 36, 536), + Trans(19, 49, 36, 536), + Trans(19, 50, 36, 536), + Trans(19, 53, 36, 536), + Trans(19, 57, 36, 536), + Trans(19, 58, 36, 536), + Trans(19, 60, 36, 536), + Trans(19, 61, 36, 536), + Trans(19, 64, 36, 536), + Trans(19, 65, 36, 536), + Trans(19, 66, 36, 536), + Trans(19, 69, 36, 536), + Trans(19, 70, 36, 536), + Trans(19, 71, 36, 536), + Trans(19, 73, 36, 536), + Trans(19, 76, 36, 536), + Trans(19, 77, 36, 536), + Trans(19, 80, 36, 536), + Trans(19, 81, 36, 536), + Trans(19, 83, 36, 536), + Trans(19, 84, 36, 536), + Trans(19, 86, 36, 536), + Trans(19, 88, 36, 536), + Trans(19, 99, 36, 536), + Trans(19, 100, 36, 536), + Trans(19, 104, 36, 536), + Trans(19, 106, 36, 536), + Trans(19, 109, 36, 536), + Trans(19, 110, 36, 536), + Trans(19, 111, 36, 536), + Trans(19, 112, 36, 536), + Trans(20, 5, 36, 536), + Trans(20, 16, 36, 536), + Trans(20, 17, 36, 536), + Trans(20, 18, 36, 536), + Trans(20, 19, 36, 536), + Trans(20, 20, 36, 536), + Trans(20, 21, 36, 536), + Trans(20, 22, 36, 536), + Trans(20, 23, 36, 536), + Trans(20, 24, 36, 536), + Trans(20, 25, 36, 536), + Trans(20, 26, 36, 536), + Trans(20, 30, 36, 536), + Trans(20, 31, 36, 536), + Trans(20, 47, 36, 536), + Trans(20, 51, 36, 536), + Trans(21, 5, 36, 536), + Trans(21, 6, 36, 536), + Trans(21, 7, 36, 536), + Trans(21, 8, 36, 536), + Trans(21, 9, 36, 536), + Trans(21, 10, 36, 536), + Trans(21, 11, 36, 536), + Trans(21, 18, 36, 536), + Trans(21, 24, 36, 536), + Trans(21, 25, 36, 536), + Trans(21, 26, 36, 536), + Trans(21, 27, 36, 536), + Trans(21, 38, 36, 536), + Trans(21, 39, 36, 536), + Trans(21, 41, 36, 536), + Trans(21, 53, 36, 536), + Trans(21, 70, 36, 536), + Trans(21, 76, 36, 536), + Trans(21, 83, 36, 536), + Trans(21, 86, 36, 536), + Trans(21, 88, 36, 536), + Trans(21, 111, 36, 536), + Trans(21, 112, 36, 536), + Trans(22, 5, 36, 536), + Trans(22, 112, 36, 536), + Trans(23, 5, 36, 536), + Trans(23, 40, 36, 536), + Trans(24, 5, 36, 536), + Trans(24, 6, 36, 536), + Trans(24, 7, 36, 536), + Trans(24, 8, 36, 536), + Trans(24, 9, 36, 536), + Trans(24, 10, 36, 536), + Trans(24, 11, 36, 536), + Trans(24, 18, 36, 536), + Trans(24, 24, 36, 536), + Trans(24, 25, 36, 536), + Trans(24, 26, 36, 536), + Trans(24, 27, 36, 536), + Trans(24, 38, 36, 536), + Trans(24, 39, 36, 536), + Trans(24, 41, 36, 536), + Trans(24, 53, 36, 536), + Trans(24, 57, 36, 536), + Trans(24, 70, 36, 536), + Trans(24, 76, 36, 536), + Trans(24, 83, 36, 536), + Trans(24, 86, 36, 536), + Trans(24, 88, 36, 536), + Trans(24, 111, 36, 536), + Trans(24, 112, 36, 536), + Trans(25, 5, 36, 536), + Trans(25, 6, 36, 536), + Trans(25, 7, 36, 536), + Trans(25, 8, 36, 536), + Trans(25, 9, 36, 536), + Trans(25, 10, 36, 536), + Trans(25, 11, 36, 536), + Trans(25, 18, 36, 536), + Trans(25, 24, 36, 536), + Trans(25, 25, 36, 536), + Trans(25, 26, 36, 536), + Trans(25, 27, 36, 536), + Trans(25, 30, 36, 536), + Trans(25, 36, 36, 536), + Trans(25, 38, 36, 536), + Trans(25, 39, 36, 536), + Trans(25, 41, 36, 536), + Trans(25, 43, 36, 536), + Trans(25, 48, 36, 536), + Trans(25, 49, 36, 536), + Trans(25, 50, 36, 536), + Trans(25, 53, 36, 536), + Trans(25, 60, 36, 536), + Trans(25, 61, 36, 536), + Trans(25, 64, 36, 536), + Trans(25, 65, 36, 536), + Trans(25, 66, 36, 536), + Trans(25, 70, 36, 536), + Trans(25, 71, 36, 536), + Trans(25, 73, 36, 536), + Trans(25, 76, 36, 536), + Trans(25, 77, 36, 536), + Trans(25, 80, 36, 536), + Trans(25, 81, 36, 536), + Trans(25, 83, 36, 536), + Trans(25, 84, 36, 536), + Trans(25, 86, 36, 536), + Trans(25, 88, 36, 536), + Trans(25, 104, 36, 536), + Trans(25, 106, 36, 536), + Trans(25, 109, 36, 536), + Trans(25, 110, 36, 536), + Trans(25, 111, 36, 536), + Trans(25, 112, 36, 536), + Trans(26, 0, 36, 536), + Trans(26, 5, 36, 536), + Trans(26, 6, 36, 536), + Trans(26, 7, 36, 536), + Trans(26, 8, 36, 536), + Trans(26, 9, 36, 536), + Trans(26, 10, 36, 536), + Trans(26, 11, 36, 536), + Trans(26, 18, 36, 536), + Trans(26, 24, 36, 536), + Trans(26, 25, 36, 536), + Trans(26, 26, 36, 536), + Trans(26, 27, 36, 536), + Trans(26, 30, 36, 536), + Trans(26, 36, 36, 536), + Trans(26, 38, 36, 536), + Trans(26, 39, 36, 536), + Trans(26, 41, 36, 536), + Trans(26, 43, 36, 536), + Trans(26, 48, 36, 536), + Trans(26, 49, 36, 536), + Trans(26, 50, 36, 536), + Trans(26, 53, 36, 536), + Trans(26, 57, 36, 536), + Trans(26, 58, 36, 536), + Trans(26, 59, 36, 536), + Trans(26, 60, 36, 536), + Trans(26, 61, 36, 536), + Trans(26, 64, 36, 536), + Trans(26, 65, 36, 536), + Trans(26, 66, 36, 536), + Trans(26, 69, 36, 536), + Trans(26, 70, 36, 536), + Trans(26, 71, 36, 536), + Trans(26, 72, 36, 536), + Trans(26, 73, 36, 536), + Trans(26, 76, 36, 536), + Trans(26, 77, 36, 536), + Trans(26, 78, 36, 536), + Trans(26, 80, 36, 536), + Trans(26, 81, 36, 536), + Trans(26, 83, 36, 536), + Trans(26, 84, 36, 536), + Trans(26, 85, 36, 536), + Trans(26, 86, 36, 536), + Trans(26, 88, 36, 536), + Trans(26, 89, 36, 536), + Trans(26, 91, 36, 536), + Trans(26, 99, 36, 536), + Trans(26, 100, 36, 536), + Trans(26, 104, 36, 536), + Trans(26, 106, 36, 536), + Trans(26, 109, 36, 536), + Trans(26, 110, 36, 536), + Trans(26, 111, 36, 536), + Trans(26, 112, 36, 536), + Trans(27, 5, 36, 536), + Trans(27, 39, 36, 536), + Trans(28, 5, 36, 536), + Trans(28, 41, 36, 536), + Trans(29, 5, 36, 536), + Trans(29, 30, 36, 536), + Trans(30, 5, 36, 536), + Trans(30, 39, 36, 536), + Trans(30, 70, 36, 536), + Trans(31, 5, 36, 536), + Trans(31, 47, 36, 536), + Trans(31, 111, 36, 536), + Trans(31, 112, 36, 536), + Trans(32, 5, 36, 536), + Trans(32, 111, 36, 536), + Trans(32, 112, 36, 536), + Trans(33, 5, 36, 536), + Trans(33, 46, 36, 536), + Trans(34, 5, 36, 536), + Trans(34, 15, 36, 536), + Trans(34, 16, 36, 536), + Trans(34, 17, 36, 536), + Trans(34, 18, 36, 536), + Trans(34, 19, 36, 536), + Trans(34, 20, 36, 536), + Trans(34, 21, 36, 536), + Trans(34, 22, 36, 536), + Trans(34, 23, 36, 536), + Trans(34, 24, 36, 536), + Trans(34, 25, 36, 536), + Trans(34, 26, 36, 536), + Trans(34, 29, 36, 536), + Trans(34, 30, 36, 536), + Trans(34, 31, 36, 536), + Trans(34, 34, 36, 536), + Trans(34, 35, 36, 536), + Trans(34, 40, 36, 536), + Trans(34, 41, 36, 536), + Trans(34, 47, 36, 536), + Trans(34, 51, 36, 536), + Trans(35, 5, 36, 536), + Trans(35, 15, 36, 536), + Trans(35, 16, 36, 536), + Trans(35, 17, 36, 536), + Trans(35, 18, 36, 536), + Trans(35, 19, 36, 536), + Trans(35, 20, 36, 536), + Trans(35, 21, 36, 536), + Trans(35, 22, 36, 536), + Trans(35, 23, 36, 536), + Trans(35, 24, 36, 536), + Trans(35, 25, 36, 536), + Trans(35, 26, 36, 536), + Trans(35, 28, 36, 536), + Trans(35, 29, 36, 536), + Trans(35, 30, 36, 536), + Trans(35, 31, 36, 536), + Trans(35, 34, 36, 536), + Trans(35, 35, 36, 536), + Trans(35, 40, 36, 536), + Trans(35, 41, 36, 536), + Trans(35, 47, 36, 536), + Trans(35, 51, 36, 536), + Trans(37, 6, 36, 536), + Trans(37, 7, 36, 536), + Trans(37, 8, 36, 536), + Trans(37, 9, 36, 536), + Trans(37, 10, 36, 536), + Trans(37, 11, 36, 536), + Trans(37, 18, 36, 536), + Trans(37, 24, 36, 536), + Trans(37, 25, 36, 536), + Trans(37, 26, 36, 536), + Trans(37, 27, 36, 536), + Trans(37, 38, 36, 536), + Trans(37, 39, 36, 536), + Trans(37, 41, 36, 536), + Trans(37, 53, 36, 536), + Trans(37, 70, 36, 536), + Trans(37, 76, 36, 536), + Trans(37, 83, 36, 536), + Trans(37, 86, 36, 536), + Trans(37, 88, 36, 536), + Trans(37, 111, 36, 536), + Trans(37, 112, 36, 536), + Trans(38, 5, 36, 536), + Trans(38, 16, 36, 536), + Trans(38, 17, 36, 536), + Trans(38, 18, 36, 536), + Trans(38, 19, 36, 536), + Trans(38, 20, 36, 536), + Trans(38, 21, 36, 536), + Trans(38, 22, 36, 536), + Trans(38, 23, 36, 536), + Trans(38, 24, 36, 536), + Trans(38, 25, 36, 536), + Trans(38, 26, 36, 536), + Trans(38, 29, 36, 536), + Trans(38, 30, 36, 536), + Trans(38, 31, 36, 536), + Trans(38, 34, 36, 536), + Trans(38, 40, 36, 536), + Trans(38, 41, 36, 536), + Trans(38, 47, 36, 536), + Trans(38, 51, 36, 536), + Trans(39, 5, 36, 536), + Trans(39, 16, 36, 536), + Trans(39, 17, 36, 536), + Trans(39, 18, 36, 536), + Trans(39, 19, 36, 536), + Trans(39, 20, 36, 536), + Trans(39, 21, 36, 536), + Trans(39, 22, 36, 536), + Trans(39, 23, 36, 536), + Trans(39, 24, 36, 536), + Trans(39, 25, 36, 536), + Trans(39, 26, 36, 536), + Trans(39, 28, 36, 536), + Trans(39, 29, 36, 536), + Trans(39, 30, 36, 536), + Trans(39, 31, 36, 536), + Trans(39, 34, 36, 536), + Trans(39, 40, 36, 536), + Trans(39, 41, 36, 536), + Trans(39, 47, 36, 536), + Trans(39, 51, 36, 536), + Trans(40, 6, 36, 536), + Trans(40, 7, 36, 536), + Trans(40, 8, 36, 536), + Trans(40, 9, 36, 536), + Trans(40, 10, 36, 536), + Trans(40, 11, 36, 536), + Trans(40, 18, 36, 536), + Trans(40, 24, 36, 536), + Trans(40, 25, 36, 536), + Trans(40, 26, 36, 536), + Trans(40, 27, 36, 536), + Trans(40, 38, 36, 536), + Trans(40, 39, 36, 536), + Trans(40, 41, 36, 536), + Trans(40, 53, 36, 536), + Trans(40, 57, 36, 536), + Trans(40, 70, 36, 536), + Trans(40, 76, 36, 536), + Trans(40, 83, 36, 536), + Trans(40, 86, 36, 536), + Trans(40, 88, 36, 536), + Trans(40, 111, 36, 536), + Trans(40, 112, 36, 536), + Trans(41, 5, 36, 536), + Trans(41, 16, 36, 536), + Trans(41, 17, 36, 536), + Trans(41, 18, 36, 536), + Trans(41, 19, 36, 536), + Trans(41, 20, 36, 536), + Trans(41, 21, 36, 536), + Trans(41, 22, 36, 536), + Trans(41, 23, 36, 536), + Trans(41, 24, 36, 536), + Trans(41, 25, 36, 536), + Trans(41, 26, 36, 536), + Trans(41, 31, 36, 536), + Trans(41, 43, 36, 536), + Trans(41, 47, 36, 536), + Trans(41, 51, 36, 536), + Trans(41, 93, 36, 536), + Trans(42, 5, 36, 536), + Trans(42, 16, 36, 536), + Trans(42, 17, 36, 536), + Trans(42, 18, 36, 536), + Trans(42, 19, 36, 536), + Trans(42, 20, 36, 536), + Trans(42, 21, 36, 536), + Trans(42, 22, 36, 536), + Trans(42, 23, 36, 536), + Trans(42, 24, 36, 536), + Trans(42, 25, 36, 536), + Trans(42, 26, 36, 536), + Trans(42, 29, 36, 536), + Trans(42, 31, 36, 536), + Trans(42, 34, 36, 536), + Trans(42, 40, 36, 536), + Trans(42, 41, 36, 536), + Trans(42, 43, 36, 536), + Trans(42, 47, 36, 536), + Trans(42, 51, 36, 536), + Trans(42, 93, 36, 536), + Trans(43, 5, 36, 536), + Trans(43, 16, 36, 536), + Trans(43, 17, 36, 536), + Trans(43, 18, 36, 536), + Trans(43, 19, 36, 536), + Trans(43, 20, 36, 536), + Trans(43, 21, 36, 536), + Trans(43, 22, 36, 536), + Trans(43, 23, 36, 536), + Trans(43, 24, 36, 536), + Trans(43, 25, 36, 536), + Trans(43, 26, 36, 536), + Trans(43, 28, 36, 536), + Trans(43, 29, 36, 536), + Trans(43, 31, 36, 536), + Trans(43, 34, 36, 536), + Trans(43, 40, 36, 536), + Trans(43, 41, 36, 536), + Trans(43, 43, 36, 536), + Trans(43, 47, 36, 536), + Trans(43, 51, 36, 536), + Trans(43, 93, 36, 536), + Trans(44, 5, 36, 536), + Trans(44, 16, 36, 536), + Trans(44, 17, 36, 536), + Trans(44, 18, 36, 536), + Trans(44, 19, 36, 536), + Trans(44, 20, 36, 536), + Trans(44, 21, 36, 536), + Trans(44, 22, 36, 536), + Trans(44, 23, 36, 536), + Trans(44, 24, 36, 536), + Trans(44, 25, 36, 536), + Trans(44, 26, 36, 536), + Trans(44, 45, 36, 536), + Trans(44, 47, 36, 536), + Trans(44, 51, 36, 536), + Trans(45, 5, 36, 536), + Trans(45, 16, 36, 536), + Trans(45, 17, 36, 536), + Trans(45, 18, 36, 536), + Trans(45, 19, 36, 536), + Trans(45, 20, 36, 536), + Trans(45, 21, 36, 536), + Trans(45, 22, 36, 536), + Trans(45, 23, 36, 536), + Trans(45, 24, 36, 536), + Trans(45, 25, 36, 536), + Trans(45, 26, 36, 536), + Trans(45, 29, 36, 536), + Trans(45, 34, 36, 536), + Trans(45, 40, 36, 536), + Trans(45, 41, 36, 536), + Trans(45, 45, 36, 536), + Trans(45, 47, 36, 536), + Trans(45, 51, 36, 536), + Trans(46, 5, 36, 536), + Trans(46, 16, 36, 536), + Trans(46, 17, 36, 536), + Trans(46, 18, 36, 536), + Trans(46, 19, 36, 536), + Trans(46, 20, 36, 536), + Trans(46, 21, 36, 536), + Trans(46, 22, 36, 536), + Trans(46, 23, 36, 536), + Trans(46, 24, 36, 536), + Trans(46, 25, 36, 536), + Trans(46, 26, 36, 536), + Trans(46, 28, 36, 536), + Trans(46, 29, 36, 536), + Trans(46, 34, 36, 536), + Trans(46, 40, 36, 536), + Trans(46, 41, 36, 536), + Trans(46, 45, 36, 536), + Trans(46, 47, 36, 536), + Trans(46, 51, 36, 536), + Trans(47, 5, 36, 536), + Trans(47, 16, 36, 536), + Trans(47, 17, 36, 536), + Trans(47, 18, 36, 536), + Trans(47, 19, 36, 536), + Trans(47, 20, 36, 536), + Trans(47, 21, 36, 536), + Trans(47, 22, 36, 536), + Trans(47, 23, 36, 536), + Trans(47, 24, 36, 536), + Trans(47, 25, 36, 536), + Trans(47, 26, 36, 536), + Trans(47, 39, 36, 536), + Trans(47, 47, 36, 536), + Trans(47, 51, 36, 536), + Trans(48, 5, 36, 536), + Trans(48, 16, 36, 536), + Trans(48, 17, 36, 536), + Trans(48, 18, 36, 536), + Trans(48, 19, 36, 536), + Trans(48, 20, 36, 536), + Trans(48, 21, 36, 536), + Trans(48, 22, 36, 536), + Trans(48, 23, 36, 536), + Trans(48, 24, 36, 536), + Trans(48, 25, 36, 536), + Trans(48, 26, 36, 536), + Trans(48, 29, 36, 536), + Trans(48, 34, 36, 536), + Trans(48, 39, 36, 536), + Trans(48, 40, 36, 536), + Trans(48, 41, 36, 536), + Trans(48, 47, 36, 536), + Trans(48, 51, 36, 536), + Trans(49, 5, 36, 536), + Trans(49, 16, 36, 536), + Trans(49, 17, 36, 536), + Trans(49, 18, 36, 536), + Trans(49, 19, 36, 536), + Trans(49, 20, 36, 536), + Trans(49, 21, 36, 536), + Trans(49, 22, 36, 536), + Trans(49, 23, 36, 536), + Trans(49, 24, 36, 536), + Trans(49, 25, 36, 536), + Trans(49, 26, 36, 536), + Trans(49, 28, 36, 536), + Trans(49, 29, 36, 536), + Trans(49, 34, 36, 536), + Trans(49, 39, 36, 536), + Trans(49, 40, 36, 536), + Trans(49, 41, 36, 536), + Trans(49, 47, 36, 536), + Trans(49, 51, 36, 536), + Trans(50, 5, 36, 536), + Trans(50, 16, 36, 536), + Trans(50, 17, 36, 536), + Trans(50, 18, 36, 536), + Trans(50, 19, 36, 536), + Trans(50, 20, 36, 536), + Trans(50, 21, 36, 536), + Trans(50, 22, 36, 536), + Trans(50, 23, 36, 536), + Trans(50, 24, 36, 536), + Trans(50, 25, 36, 536), + Trans(50, 26, 36, 536), + Trans(50, 46, 36, 536), + Trans(50, 47, 36, 536), + Trans(50, 51, 36, 536), + Trans(51, 5, 36, 536), + Trans(51, 16, 36, 536), + Trans(51, 17, 36, 536), + Trans(51, 18, 36, 536), + Trans(51, 19, 36, 536), + Trans(51, 20, 36, 536), + Trans(51, 21, 36, 536), + Trans(51, 22, 36, 536), + Trans(51, 23, 36, 536), + Trans(51, 24, 36, 536), + Trans(51, 25, 36, 536), + Trans(51, 26, 36, 536), + Trans(51, 29, 36, 536), + Trans(51, 34, 36, 536), + Trans(51, 40, 36, 536), + Trans(51, 41, 36, 536), + Trans(51, 46, 36, 536), + Trans(51, 47, 36, 536), + Trans(51, 51, 36, 536), + Trans(52, 5, 36, 536), + Trans(52, 16, 36, 536), + Trans(52, 17, 36, 536), + Trans(52, 18, 36, 536), + Trans(52, 19, 36, 536), + Trans(52, 20, 36, 536), + Trans(52, 21, 36, 536), + Trans(52, 22, 36, 536), + Trans(52, 23, 36, 536), + Trans(52, 24, 36, 536), + Trans(52, 25, 36, 536), + Trans(52, 26, 36, 536), + Trans(52, 28, 36, 536), + Trans(52, 29, 36, 536), + Trans(52, 34, 36, 536), + Trans(52, 40, 36, 536), + Trans(52, 41, 36, 536), + Trans(52, 46, 36, 536), + Trans(52, 47, 36, 536), + Trans(52, 51, 36, 536), + Trans(53, 15, 36, 536), + Trans(53, 16, 36, 536), + Trans(53, 17, 36, 536), + Trans(53, 18, 36, 536), + Trans(53, 19, 36, 536), + Trans(53, 20, 36, 536), + Trans(53, 21, 36, 536), + Trans(53, 22, 36, 536), + Trans(53, 23, 36, 536), + Trans(53, 24, 36, 536), + Trans(53, 25, 36, 536), + Trans(53, 26, 36, 536), + Trans(53, 29, 36, 536), + Trans(53, 30, 36, 536), + Trans(53, 31, 36, 536), + Trans(53, 34, 36, 536), + Trans(53, 35, 36, 536), + Trans(53, 40, 36, 536), + Trans(53, 41, 36, 536), + Trans(53, 47, 36, 536), + Trans(53, 51, 36, 536), + Trans(54, 5, 36, 536), + Trans(54, 39, 36, 536), + Trans(54, 53, 36, 536), + Trans(54, 65, 36, 536), + Trans(54, 69, 36, 536), + Trans(54, 70, 36, 536), + Trans(54, 80, 36, 536), + Trans(54, 99, 36, 536), + Trans(54, 100, 36, 536), + Trans(54, 111, 36, 536), + Trans(54, 112, 36, 536), + Trans(55, 5, 36, 536), + Trans(55, 6, 36, 536), + Trans(55, 7, 36, 536), + Trans(55, 8, 36, 536), + Trans(55, 9, 36, 536), + Trans(55, 10, 36, 536), + Trans(55, 11, 36, 536), + Trans(55, 18, 36, 536), + Trans(55, 24, 36, 536), + Trans(55, 25, 36, 536), + Trans(55, 26, 36, 536), + Trans(55, 27, 36, 536), + Trans(55, 38, 36, 536), + Trans(55, 39, 36, 536), + Trans(55, 41, 36, 536), + Trans(55, 45, 36, 536), + Trans(55, 53, 36, 536), + Trans(55, 70, 36, 536), + Trans(55, 76, 36, 536), + Trans(55, 83, 36, 536), + Trans(55, 86, 36, 536), + Trans(55, 88, 36, 536), + Trans(55, 111, 36, 536), + Trans(55, 112, 36, 536), + Trans(56, 15, 36, 536), + Trans(56, 16, 36, 536), + Trans(56, 17, 36, 536), + Trans(56, 18, 36, 536), + Trans(56, 19, 36, 536), + Trans(56, 20, 36, 536), + Trans(56, 21, 36, 536), + Trans(56, 22, 36, 536), + Trans(56, 23, 36, 536), + Trans(56, 24, 36, 536), + Trans(56, 25, 36, 536), + Trans(56, 26, 36, 536), + Trans(56, 28, 36, 536), + Trans(56, 29, 36, 536), + Trans(56, 30, 36, 536), + Trans(56, 31, 36, 536), + Trans(56, 34, 36, 536), + Trans(56, 35, 36, 536), + Trans(56, 40, 36, 536), + Trans(56, 41, 36, 536), + Trans(56, 47, 36, 536), + Trans(56, 51, 36, 536), + Trans(57, 5, 36, 536), + Trans(57, 7, 36, 536), + Trans(57, 8, 36, 536), + Trans(57, 9, 36, 536), + Trans(57, 10, 36, 536), + Trans(57, 11, 36, 536), + Trans(57, 111, 36, 536), + Trans(57, 112, 36, 536), + Trans(58, 16, 36, 536), + Trans(58, 17, 36, 536), + Trans(58, 18, 36, 536), + Trans(58, 19, 36, 536), + Trans(58, 20, 36, 536), + Trans(58, 21, 36, 536), + Trans(58, 22, 36, 536), + Trans(58, 23, 36, 536), + Trans(58, 24, 36, 536), + Trans(58, 25, 36, 536), + Trans(58, 26, 36, 536), + Trans(58, 30, 36, 536), + Trans(58, 31, 36, 536), + Trans(58, 47, 36, 536), + Trans(58, 51, 36, 536), + Trans(59, 30, 36, 536), + Trans(60, 5, 36, 536), + Trans(60, 43, 36, 536), + Trans(60, 53, 36, 536), + Trans(60, 65, 36, 536), + Trans(60, 69, 36, 536), + Trans(60, 70, 36, 536), + Trans(60, 80, 36, 536), + Trans(60, 99, 36, 536), + Trans(60, 100, 36, 536), + Trans(60, 111, 36, 536), + Trans(60, 112, 36, 536), + Trans(61, 39, 36, 536), + Trans(62, 46, 36, 536), + Trans(63, 5, 36, 536), + Trans(63, 43, 36, 536), + Trans(63, 53, 36, 536), + Trans(63, 65, 36, 536), + Trans(63, 69, 36, 536), + Trans(63, 70, 36, 536), + Trans(63, 80, 36, 536), + Trans(63, 99, 36, 536), + Trans(63, 100, 36, 536), + Trans(63, 110, 36, 536), + Trans(63, 111, 36, 536), + Trans(63, 112, 36, 536), + Trans(64, 112, 36, 536), ], k: 3, }, - /* 259 - "IfStatementList0List" */ + /* 263 - "IfStatementList0List" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 528), - Trans(0, 52, 1, 527), - Trans(0, 64, 1, 527), - Trans(0, 68, 1, 527), - Trans(0, 69, 1, 527), - Trans(0, 79, 1, 527), - Trans(0, 98, 1, 527), - Trans(0, 99, 1, 527), - Trans(0, 110, 1, 527), - Trans(0, 111, 1, 527), + Trans(0, 43, 2, 535), + Trans(0, 53, 1, 534), + Trans(0, 65, 1, 534), + Trans(0, 69, 1, 534), + Trans(0, 70, 1, 534), + Trans(0, 80, 1, 534), + Trans(0, 99, 1, 534), + Trans(0, 100, 1, 534), + Trans(0, 111, 1, 534), + Trans(0, 112, 1, 534), ], k: 1, }, - /* 260 - "IfStatementOpt" */ + /* 264 - "IfStatementOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 6, 2, 535), - Trans(0, 7, 2, 535), - Trans(0, 8, 2, 535), - Trans(0, 9, 2, 535), - Trans(0, 10, 2, 535), - Trans(0, 11, 2, 535), - Trans(0, 18, 2, 535), - Trans(0, 24, 2, 535), - Trans(0, 25, 2, 535), - Trans(0, 26, 2, 535), - Trans(0, 27, 2, 535), - Trans(0, 37, 2, 535), - Trans(0, 38, 2, 535), - Trans(0, 40, 2, 535), - Trans(0, 42, 2, 535), - Trans(0, 52, 2, 535), - Trans(0, 56, 2, 535), - Trans(0, 57, 1, 532), - Trans(0, 64, 2, 535), - Trans(0, 68, 2, 535), - Trans(0, 69, 2, 535), - Trans(0, 75, 2, 535), - Trans(0, 79, 2, 535), - Trans(0, 82, 2, 535), - Trans(0, 85, 2, 535), - Trans(0, 87, 2, 535), - Trans(0, 98, 2, 535), - Trans(0, 99, 2, 535), - Trans(0, 109, 2, 535), - Trans(0, 110, 2, 535), - Trans(0, 111, 2, 535), + Trans(0, 6, 2, 542), + Trans(0, 7, 2, 542), + Trans(0, 8, 2, 542), + Trans(0, 9, 2, 542), + Trans(0, 10, 2, 542), + Trans(0, 11, 2, 542), + Trans(0, 18, 2, 542), + Trans(0, 24, 2, 542), + Trans(0, 25, 2, 542), + Trans(0, 26, 2, 542), + Trans(0, 27, 2, 542), + Trans(0, 38, 2, 542), + Trans(0, 39, 2, 542), + Trans(0, 41, 2, 542), + Trans(0, 43, 2, 542), + Trans(0, 53, 2, 542), + Trans(0, 57, 2, 542), + Trans(0, 58, 1, 539), + Trans(0, 65, 2, 542), + Trans(0, 69, 2, 542), + Trans(0, 70, 2, 542), + Trans(0, 76, 2, 542), + Trans(0, 80, 2, 542), + Trans(0, 83, 2, 542), + Trans(0, 86, 2, 542), + Trans(0, 88, 2, 542), + Trans(0, 99, 2, 542), + Trans(0, 100, 2, 542), + Trans(0, 110, 2, 542), + Trans(0, 111, 2, 542), + Trans(0, 112, 2, 542), ], k: 1, }, - /* 261 - "IfStatementOptList" */ + /* 265 - "IfStatementOptList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 534), - Trans(0, 52, 1, 533), - Trans(0, 64, 1, 533), - Trans(0, 68, 1, 533), - Trans(0, 69, 1, 533), - Trans(0, 79, 1, 533), - Trans(0, 98, 1, 533), - Trans(0, 99, 1, 533), - Trans(0, 110, 1, 533), - Trans(0, 111, 1, 533), + Trans(0, 43, 2, 541), + Trans(0, 53, 1, 540), + Trans(0, 65, 1, 540), + Trans(0, 69, 1, 540), + Trans(0, 70, 1, 540), + Trans(0, 80, 1, 540), + Trans(0, 99, 1, 540), + Trans(0, 100, 1, 540), + Trans(0, 111, 1, 540), + Trans(0, 112, 1, 540), ], k: 1, }, - /* 262 - "IfTerm" */ + /* 266 - "IfTerm" */ LookaheadDFA { - prod0: 64, + prod0: 65, transitions: &[], k: 0, }, - /* 263 - "IfToken" */ + /* 267 - "IfToken" */ LookaheadDFA { - prod0: 175, + prod0: 177, transitions: &[], k: 0, }, - /* 264 - "Import" */ + /* 268 - "Import" */ LookaheadDFA { - prod0: 284, + prod0: 287, transitions: &[], k: 0, }, - /* 265 - "ImportDeclaration" */ + /* 269 - "ImportDeclaration" */ LookaheadDFA { - prod0: 727, + prod0: 753, transitions: &[], k: 0, }, - /* 266 - "ImportDeclarationOpt" */ + /* 270 - "ImportDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 28, 1, 728), Trans(0, 45, 2, 729)], + transitions: &[Trans(0, 29, 1, 754), Trans(0, 46, 2, 755)], k: 1, }, - /* 267 - "ImportTerm" */ + /* 271 - "ImportTerm" */ LookaheadDFA { - prod0: 65, + prod0: 66, transitions: &[], k: 0, }, - /* 268 - "ImportToken" */ + /* 272 - "ImportToken" */ LookaheadDFA { - prod0: 176, + prod0: 178, transitions: &[], k: 0, }, - /* 269 - "In" */ + /* 273 - "In" */ LookaheadDFA { - prod0: 285, + prod0: 288, transitions: &[], k: 0, }, - /* 270 - "InTerm" */ + /* 274 - "InTerm" */ LookaheadDFA { - prod0: 73, + prod0: 74, transitions: &[], k: 0, }, - /* 271 - "InToken" */ + /* 275 - "InToken" */ LookaheadDFA { - prod0: 184, + prod0: 186, transitions: &[], k: 0, }, - /* 272 - "Include" */ + /* 276 - "Include" */ LookaheadDFA { - prod0: 286, + prod0: 289, transitions: &[], k: 0, }, - /* 273 - "IncludeDeclaration" */ + /* 277 - "IncludeDeclaration" */ LookaheadDFA { - prod0: 859, + prod0: 891, transitions: &[], k: 0, }, - /* 274 - "IncludeTerm" */ + /* 278 - "IncludeTerm" */ LookaheadDFA { - prod0: 66, + prod0: 67, transitions: &[], k: 0, }, - /* 275 - "IncludeToken" */ + /* 279 - "IncludeToken" */ LookaheadDFA { - prod0: 177, + prod0: 179, transitions: &[], k: 0, }, - /* 276 - "Initial" */ + /* 280 - "Initial" */ LookaheadDFA { - prod0: 287, + prod0: 290, transitions: &[], k: 0, }, - /* 277 - "InitialDeclaration" */ + /* 281 - "InitialDeclaration" */ LookaheadDFA { - prod0: 633, + prod0: 642, transitions: &[], k: 0, }, - /* 278 - "InitialDeclarationList" */ + /* 282 - "InitialDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 42, 2, 635), - Trans(0, 52, 1, 634), - Trans(0, 64, 1, 634), - Trans(0, 68, 1, 634), - Trans(0, 69, 1, 634), - Trans(0, 79, 1, 634), - Trans(0, 98, 1, 634), - Trans(0, 99, 1, 634), - Trans(0, 110, 1, 634), - Trans(0, 111, 1, 634), + Trans(0, 43, 2, 644), + Trans(0, 53, 1, 643), + Trans(0, 65, 1, 643), + Trans(0, 69, 1, 643), + Trans(0, 70, 1, 643), + Trans(0, 80, 1, 643), + Trans(0, 99, 1, 643), + Trans(0, 100, 1, 643), + Trans(0, 111, 1, 643), + Trans(0, 112, 1, 643), ], k: 1, }, - /* 279 - "InitialTerm" */ + /* 283 - "InitialTerm" */ LookaheadDFA { - prod0: 67, + prod0: 68, transitions: &[], k: 0, }, - /* 280 - "InitialToken" */ + /* 284 - "InitialToken" */ LookaheadDFA { - prod0: 178, + prod0: 180, transitions: &[], k: 0, }, - /* 281 - "Inout" */ + /* 285 - "Inout" */ LookaheadDFA { - prod0: 288, + prod0: 291, transitions: &[], k: 0, }, - /* 282 - "InoutTerm" */ + /* 286 - "InoutTerm" */ LookaheadDFA { - prod0: 68, + prod0: 69, transitions: &[], k: 0, }, - /* 283 - "InoutToken" */ + /* 287 - "InoutToken" */ LookaheadDFA { - prod0: 179, + prod0: 181, transitions: &[], k: 0, }, - /* 284 - "Input" */ + /* 288 - "Input" */ LookaheadDFA { - prod0: 289, + prod0: 292, transitions: &[], k: 0, }, - /* 285 - "InputTerm" */ + /* 289 - "InputTerm" */ LookaheadDFA { - prod0: 69, + prod0: 70, transitions: &[], k: 0, }, - /* 286 - "InputToken" */ + /* 290 - "InputToken" */ LookaheadDFA { - prod0: 180, + prod0: 182, transitions: &[], k: 0, }, - /* 287 - "Inside" */ + /* 291 - "Inside" */ LookaheadDFA { - prod0: 290, + prod0: 293, transitions: &[], k: 0, }, - /* 288 - "InsideExpression" */ + /* 292 - "InsideExpression" */ LookaheadDFA { - prod0: 453, + prod0: 460, transitions: &[], k: 0, }, - /* 289 - "InsideTerm" */ + /* 293 - "InsideTerm" */ LookaheadDFA { - prod0: 70, + prod0: 71, transitions: &[], k: 0, }, - /* 290 - "InsideToken" */ + /* 294 - "InsideToken" */ LookaheadDFA { - prod0: 181, + prod0: 183, transitions: &[], k: 0, }, - /* 291 - "Inst" */ + /* 295 - "Inst" */ LookaheadDFA { - prod0: 291, + prod0: 294, transitions: &[], k: 0, }, - /* 292 - "InstDeclaration" */ + /* 296 - "InstDeclaration" */ LookaheadDFA { - prod0: 639, + prod0: 648, transitions: &[], k: 0, }, - /* 293 - "InstDeclarationOpt" */ + /* 297 - "InstDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 2, 647), - Trans(0, 39, 1, 646), - Trans(0, 40, 2, 647), - Trans(0, 45, 2, 647), + Trans(0, 36, 2, 656), + Trans(0, 40, 1, 655), + Trans(0, 41, 2, 656), + Trans(0, 46, 2, 656), ], k: 1, }, - /* 294 - "InstDeclarationOpt0" */ + /* 298 - "InstDeclarationOpt0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 644), - Trans(0, 40, 2, 645), - Trans(0, 45, 2, 645), + Trans(0, 36, 1, 653), + Trans(0, 41, 2, 654), + Trans(0, 46, 2, 654), ], k: 1, }, - /* 295 - "InstDeclarationOpt1" */ + /* 299 - "InstDeclarationOpt1" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 40, 1, 640), Trans(0, 45, 2, 643)], + transitions: &[Trans(0, 41, 1, 649), Trans(0, 46, 2, 652)], k: 1, }, - /* 296 - "InstDeclarationOpt2" */ + /* 300 - "InstDeclarationOpt2" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 641), - Trans(0, 38, 1, 641), - Trans(0, 44, 2, 642), - Trans(0, 111, 1, 641), + Trans(0, 36, 1, 650), + Trans(0, 39, 1, 650), + Trans(0, 45, 2, 651), + Trans(0, 112, 1, 650), ], k: 1, }, - /* 297 - "InstParameter" */ + /* 301 - "InstParameter" */ LookaheadDFA { - prod0: 648, + prod0: 657, transitions: &[], k: 0, }, - /* 298 - "InstParameterGroup" */ + /* 302 - "InstParameterGroup" */ LookaheadDFA { - prod0: 656, + prod0: 665, transitions: &[], k: 0, }, - /* 299 - "InstParameterGroupGroup" */ + /* 303 - "InstParameterGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 38, 1, 657), Trans(0, 111, 2, 658)], + transitions: &[Trans(0, 39, 1, 666), Trans(0, 112, 2, 667)], k: 1, }, - /* 300 - "InstParameterGroupList" */ + /* 304 - "InstParameterGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 659), - Trans(0, 38, 2, 660), - Trans(0, 111, 2, 660), + Trans(0, 36, 1, 668), + Trans(0, 39, 2, 669), + Trans(0, 112, 2, 669), ], k: 1, }, - /* 301 - "InstParameterItem" */ + /* 305 - "InstParameterItem" */ LookaheadDFA { - prod0: 661, + prod0: 670, transitions: &[], k: 0, }, - /* 302 - "InstParameterItemOpt" */ + /* 306 - "InstParameterItemOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 662), - Trans(0, 30, 2, 663), - Trans(0, 42, 2, 663), - Trans(0, 44, 2, 663), + Trans(0, 30, 1, 671), + Trans(0, 31, 2, 672), + Trans(0, 43, 2, 672), + Trans(0, 45, 2, 672), ], k: 1, }, - /* 303 - "InstParameterList" */ + /* 307 - "InstParameterList" */ LookaheadDFA { - prod0: 651, + prod0: 660, transitions: &[], k: 0, }, - /* 304 - "InstParameterListList" */ + /* 308 - "InstParameterListList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 7, -1), - Trans(0, 44, 8, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 7, -1), + Trans(0, 45, 8, -1), Trans(1, 5, 6, -1), - Trans(1, 35, 2, -1), - Trans(1, 38, 4, -1), - Trans(1, 42, 11, -1), - Trans(1, 44, 12, -1), - Trans(1, 111, 5, -1), - Trans(2, 5, 3, 652), - Trans(2, 39, 3, 652), - Trans(4, 5, 3, 652), - Trans(4, 35, 3, 652), - Trans(4, 38, 3, 652), - Trans(4, 111, 3, 652), - Trans(5, 5, 3, 652), - Trans(5, 29, 3, 652), - Trans(5, 30, 3, 652), - Trans(5, 42, 3, 652), - Trans(5, 44, 3, 652), - Trans(6, 35, 3, 652), - Trans(6, 38, 3, 652), - Trans(6, 42, 13, 653), - Trans(6, 44, 13, 653), - Trans(6, 111, 3, 652), + Trans(1, 36, 2, -1), + Trans(1, 39, 4, -1), + Trans(1, 43, 11, -1), + Trans(1, 45, 12, -1), + Trans(1, 112, 5, -1), + Trans(2, 5, 3, 661), + Trans(2, 40, 3, 661), + Trans(4, 5, 3, 661), + Trans(4, 36, 3, 661), + Trans(4, 39, 3, 661), + Trans(4, 112, 3, 661), + Trans(5, 5, 3, 661), + Trans(5, 30, 3, 661), + Trans(5, 31, 3, 661), + Trans(5, 43, 3, 661), + Trans(5, 45, 3, 661), + Trans(6, 36, 3, 661), + Trans(6, 39, 3, 661), + Trans(6, 43, 13, 662), + Trans(6, 45, 13, 662), + Trans(6, 112, 3, 661), Trans(7, 5, 9, -1), - Trans(7, 30, 10, -1), - Trans(7, 42, 11, -1), - Trans(7, 44, 12, -1), + Trans(7, 31, 10, -1), + Trans(7, 43, 11, -1), + Trans(7, 45, 12, -1), Trans(8, 5, 14, -1), - Trans(8, 40, 15, -1), - Trans(8, 45, 16, -1), - Trans(9, 30, 13, 653), - Trans(9, 42, 13, 653), - Trans(9, 44, 13, 653), - Trans(10, 5, 13, 653), - Trans(10, 35, 13, 653), - Trans(10, 38, 13, 653), - Trans(10, 42, 13, 653), - Trans(10, 44, 13, 653), - Trans(10, 111, 13, 653), - Trans(11, 5, 13, 653), - Trans(11, 30, 13, 653), - Trans(11, 42, 13, 653), - Trans(11, 44, 13, 653), - Trans(12, 5, 13, 653), - Trans(12, 40, 13, 653), - Trans(12, 45, 13, 653), - Trans(14, 40, 13, 653), - Trans(14, 45, 13, 653), - Trans(15, 5, 13, 653), - Trans(15, 35, 13, 653), - Trans(15, 38, 13, 653), - Trans(15, 44, 13, 653), - Trans(15, 111, 13, 653), - Trans(16, 5, 13, 653), - Trans(16, 29, 13, 653), - Trans(16, 35, 13, 653), - Trans(16, 38, 13, 653), - Trans(16, 42, 13, 653), - Trans(16, 47, 13, 653), - Trans(16, 48, 13, 653), - Trans(16, 49, 13, 653), - Trans(16, 59, 13, 653), - Trans(16, 63, 13, 653), - Trans(16, 64, 13, 653), - Trans(16, 65, 13, 653), - Trans(16, 69, 13, 653), - Trans(16, 70, 13, 653), - Trans(16, 72, 13, 653), - Trans(16, 76, 13, 653), - Trans(16, 79, 13, 653), - Trans(16, 80, 13, 653), - Trans(16, 103, 13, 653), - Trans(16, 105, 13, 653), - Trans(16, 108, 13, 653), - Trans(16, 109, 13, 653), + Trans(8, 41, 15, -1), + Trans(8, 46, 16, -1), + Trans(9, 31, 13, 662), + Trans(9, 43, 13, 662), + Trans(9, 45, 13, 662), + Trans(10, 5, 13, 662), + Trans(10, 36, 13, 662), + Trans(10, 39, 13, 662), + Trans(10, 43, 13, 662), + Trans(10, 45, 13, 662), + Trans(10, 112, 13, 662), + Trans(11, 5, 13, 662), + Trans(11, 31, 13, 662), + Trans(11, 43, 13, 662), + Trans(11, 45, 13, 662), + Trans(12, 5, 13, 662), + Trans(12, 41, 13, 662), + Trans(12, 46, 13, 662), + Trans(14, 41, 13, 662), + Trans(14, 46, 13, 662), + Trans(15, 5, 13, 662), + Trans(15, 36, 13, 662), + Trans(15, 39, 13, 662), + Trans(15, 45, 13, 662), + Trans(15, 112, 13, 662), + Trans(16, 5, 13, 662), + Trans(16, 30, 13, 662), + Trans(16, 36, 13, 662), + Trans(16, 39, 13, 662), + Trans(16, 43, 13, 662), + Trans(16, 48, 13, 662), + Trans(16, 49, 13, 662), + Trans(16, 50, 13, 662), + Trans(16, 60, 13, 662), + Trans(16, 64, 13, 662), + Trans(16, 65, 13, 662), + Trans(16, 66, 13, 662), + Trans(16, 70, 13, 662), + Trans(16, 71, 13, 662), + Trans(16, 73, 13, 662), + Trans(16, 77, 13, 662), + Trans(16, 80, 13, 662), + Trans(16, 81, 13, 662), + Trans(16, 104, 13, 662), + Trans(16, 106, 13, 662), + Trans(16, 109, 13, 662), + Trans(16, 110, 13, 662), ], k: 3, }, - /* 305 - "InstParameterListOpt" */ + /* 309 - "InstParameterListOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, 654), - Trans(0, 42, 2, 655), - Trans(0, 44, 2, 655), + Trans(0, 31, 1, 663), + Trans(0, 43, 2, 664), + Trans(0, 45, 2, 664), ], k: 1, }, - /* 306 - "InstParameterOpt" */ + /* 310 - "InstParameterOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 649), - Trans(0, 38, 1, 649), - Trans(0, 44, 2, 650), - Trans(0, 111, 1, 649), + Trans(0, 36, 1, 658), + Trans(0, 39, 1, 658), + Trans(0, 45, 2, 659), + Trans(0, 112, 1, 658), ], k: 1, }, - /* 307 - "InstPortGroup" */ + /* 311 - "InstPortGroup" */ LookaheadDFA { - prod0: 669, + prod0: 678, transitions: &[], k: 0, }, - /* 308 - "InstPortGroupGroup" */ + /* 312 - "InstPortGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 38, 1, 670), Trans(0, 111, 2, 671)], + transitions: &[Trans(0, 39, 1, 679), Trans(0, 112, 2, 680)], k: 1, }, - /* 309 - "InstPortGroupList" */ + /* 313 - "InstPortGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 672), - Trans(0, 38, 2, 673), - Trans(0, 111, 2, 673), + Trans(0, 36, 1, 681), + Trans(0, 39, 2, 682), + Trans(0, 112, 2, 682), ], k: 1, }, - /* 310 - "InstPortItem" */ + /* 314 - "InstPortItem" */ LookaheadDFA { - prod0: 674, + prod0: 683, transitions: &[], k: 0, }, - /* 311 - "InstPortItemOpt" */ + /* 315 - "InstPortItemOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 675), - Trans(0, 30, 2, 676), - Trans(0, 42, 2, 676), - Trans(0, 44, 2, 676), + Trans(0, 30, 1, 684), + Trans(0, 31, 2, 685), + Trans(0, 43, 2, 685), + Trans(0, 45, 2, 685), ], k: 1, }, - /* 312 - "InstPortList" */ + /* 316 - "InstPortList" */ LookaheadDFA { - prod0: 664, + prod0: 673, transitions: &[], k: 0, }, - /* 313 - "InstPortListList" */ + /* 317 - "InstPortListList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 7, -1), - Trans(0, 44, 8, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 7, -1), + Trans(0, 45, 8, -1), Trans(1, 5, 6, -1), - Trans(1, 35, 2, -1), - Trans(1, 38, 4, -1), - Trans(1, 42, 11, -1), - Trans(1, 44, 12, -1), - Trans(1, 111, 5, -1), - Trans(2, 5, 3, 665), - Trans(2, 39, 3, 665), - Trans(4, 5, 3, 665), - Trans(4, 35, 3, 665), - Trans(4, 38, 3, 665), - Trans(4, 111, 3, 665), - Trans(5, 5, 3, 665), - Trans(5, 29, 3, 665), - Trans(5, 30, 3, 665), - Trans(5, 42, 3, 665), - Trans(5, 44, 3, 665), - Trans(6, 35, 3, 665), - Trans(6, 38, 3, 665), - Trans(6, 42, 13, 666), - Trans(6, 44, 13, 666), - Trans(6, 111, 3, 665), + Trans(1, 36, 2, -1), + Trans(1, 39, 4, -1), + Trans(1, 43, 11, -1), + Trans(1, 45, 12, -1), + Trans(1, 112, 5, -1), + Trans(2, 5, 3, 674), + Trans(2, 40, 3, 674), + Trans(4, 5, 3, 674), + Trans(4, 36, 3, 674), + Trans(4, 39, 3, 674), + Trans(4, 112, 3, 674), + Trans(5, 5, 3, 674), + Trans(5, 30, 3, 674), + Trans(5, 31, 3, 674), + Trans(5, 43, 3, 674), + Trans(5, 45, 3, 674), + Trans(6, 36, 3, 674), + Trans(6, 39, 3, 674), + Trans(6, 43, 13, 675), + Trans(6, 45, 13, 675), + Trans(6, 112, 3, 674), Trans(7, 5, 9, -1), - Trans(7, 30, 10, -1), - Trans(7, 42, 11, -1), - Trans(7, 44, 12, -1), + Trans(7, 31, 10, -1), + Trans(7, 43, 11, -1), + Trans(7, 45, 12, -1), Trans(8, 5, 14, -1), - Trans(8, 45, 15, -1), - Trans(9, 30, 13, 666), - Trans(9, 42, 13, 666), - Trans(9, 44, 13, 666), - Trans(10, 5, 13, 666), - Trans(10, 35, 13, 666), - Trans(10, 38, 13, 666), - Trans(10, 42, 13, 666), - Trans(10, 44, 13, 666), - Trans(10, 111, 13, 666), - Trans(11, 5, 13, 666), - Trans(11, 30, 13, 666), - Trans(11, 42, 13, 666), - Trans(11, 44, 13, 666), - Trans(12, 5, 13, 666), - Trans(12, 45, 13, 666), - Trans(14, 45, 13, 666), - Trans(15, 5, 13, 666), - Trans(15, 29, 13, 666), - Trans(15, 35, 13, 666), - Trans(15, 38, 13, 666), - Trans(15, 42, 13, 666), - Trans(15, 47, 13, 666), - Trans(15, 48, 13, 666), - Trans(15, 49, 13, 666), - Trans(15, 59, 13, 666), - Trans(15, 63, 13, 666), - Trans(15, 64, 13, 666), - Trans(15, 65, 13, 666), - Trans(15, 69, 13, 666), - Trans(15, 70, 13, 666), - Trans(15, 72, 13, 666), - Trans(15, 76, 13, 666), - Trans(15, 79, 13, 666), - Trans(15, 80, 13, 666), - Trans(15, 103, 13, 666), - Trans(15, 105, 13, 666), - Trans(15, 108, 13, 666), - Trans(15, 109, 13, 666), + Trans(8, 46, 15, -1), + Trans(9, 31, 13, 675), + Trans(9, 43, 13, 675), + Trans(9, 45, 13, 675), + Trans(10, 5, 13, 675), + Trans(10, 36, 13, 675), + Trans(10, 39, 13, 675), + Trans(10, 43, 13, 675), + Trans(10, 45, 13, 675), + Trans(10, 112, 13, 675), + Trans(11, 5, 13, 675), + Trans(11, 31, 13, 675), + Trans(11, 43, 13, 675), + Trans(11, 45, 13, 675), + Trans(12, 5, 13, 675), + Trans(12, 46, 13, 675), + Trans(14, 46, 13, 675), + Trans(15, 5, 13, 675), + Trans(15, 30, 13, 675), + Trans(15, 36, 13, 675), + Trans(15, 39, 13, 675), + Trans(15, 43, 13, 675), + Trans(15, 48, 13, 675), + Trans(15, 49, 13, 675), + Trans(15, 50, 13, 675), + Trans(15, 60, 13, 675), + Trans(15, 64, 13, 675), + Trans(15, 65, 13, 675), + Trans(15, 66, 13, 675), + Trans(15, 70, 13, 675), + Trans(15, 71, 13, 675), + Trans(15, 73, 13, 675), + Trans(15, 77, 13, 675), + Trans(15, 80, 13, 675), + Trans(15, 81, 13, 675), + Trans(15, 104, 13, 675), + Trans(15, 106, 13, 675), + Trans(15, 109, 13, 675), + Trans(15, 110, 13, 675), ], k: 3, }, - /* 314 - "InstPortListOpt" */ + /* 318 - "InstPortListOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, 667), - Trans(0, 42, 2, 668), - Trans(0, 44, 2, 668), + Trans(0, 31, 1, 676), + Trans(0, 43, 2, 677), + Trans(0, 45, 2, 677), ], k: 1, }, - /* 315 - "InstTerm" */ + /* 319 - "InstTerm" */ LookaheadDFA { - prod0: 71, + prod0: 72, transitions: &[], k: 0, }, - /* 316 - "InstToken" */ + /* 320 - "InstToken" */ LookaheadDFA { - prod0: 182, + prod0: 184, transitions: &[], k: 0, }, - /* 317 - "IntegralNumber" */ + /* 321 - "IntegralNumber" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 9, 1, 327), - Trans(0, 10, 3, 329), - Trans(0, 11, 2, 328), + Trans(0, 9, 1, 330), + Trans(0, 10, 3, 332), + Trans(0, 11, 2, 331), ], k: 1, }, - /* 318 - "Interface" */ + /* 322 - "Interface" */ LookaheadDFA { - prod0: 292, + prod0: 295, transitions: &[], k: 0, }, - /* 319 - "InterfaceDeclaration" */ + /* 323 - "InterfaceDeclaration" */ LookaheadDFA { - prod0: 784, + prod0: 812, transitions: &[], k: 0, }, - /* 320 - "InterfaceDeclarationList" */ + /* 324 - "InterfaceDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 785), - Trans(0, 35, 1, 785), - Trans(0, 38, 1, 785), - Trans(0, 42, 2, 786), - Trans(0, 59, 1, 785), - Trans(0, 63, 1, 785), - Trans(0, 64, 1, 785), - Trans(0, 65, 1, 785), - Trans(0, 69, 1, 785), - Trans(0, 70, 1, 785), - Trans(0, 72, 1, 785), - Trans(0, 79, 1, 785), - Trans(0, 80, 1, 785), - Trans(0, 83, 1, 785), - Trans(0, 103, 1, 785), - Trans(0, 105, 1, 785), - Trans(0, 108, 1, 785), - Trans(0, 109, 1, 785), + Trans(0, 30, 1, 813), + Trans(0, 36, 1, 813), + Trans(0, 39, 1, 813), + Trans(0, 43, 2, 814), + Trans(0, 60, 1, 813), + Trans(0, 64, 1, 813), + Trans(0, 65, 1, 813), + Trans(0, 66, 1, 813), + Trans(0, 70, 1, 813), + Trans(0, 71, 1, 813), + Trans(0, 73, 1, 813), + Trans(0, 80, 1, 813), + Trans(0, 81, 1, 813), + Trans(0, 84, 1, 813), + Trans(0, 104, 1, 813), + Trans(0, 106, 1, 813), + Trans(0, 109, 1, 813), + Trans(0, 110, 1, 813), ], k: 1, }, - /* 321 - "InterfaceDeclarationOpt" */ + /* 325 - "InterfaceDeclarationOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 78, 2, 820), Trans(0, 91, 1, 819)], + k: 1, + }, + /* 326 - "InterfaceDeclarationOpt0" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 77, 2, 790), Trans(0, 90, 1, 789)], + transitions: &[ + Trans(0, 28, 1, 817), + Trans(0, 36, 2, 818), + Trans(0, 39, 2, 818), + ], k: 1, }, - /* 322 - "InterfaceDeclarationOpt0" */ + /* 327 - "InterfaceDeclarationOpt1" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 35, 1, 787), Trans(0, 38, 2, 788)], + transitions: &[Trans(0, 36, 1, 815), Trans(0, 39, 2, 816)], k: 1, }, - /* 323 - "InterfaceForDeclaration" */ + /* 328 - "InterfaceForDeclaration" */ LookaheadDFA { - prod0: 796, + prod0: 826, transitions: &[], k: 0, }, - /* 324 - "InterfaceForDeclarationOpt" */ + /* 329 - "InterfaceForDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 29, 2, 798), Trans(0, 101, 1, 797)], + transitions: &[Trans(0, 30, 2, 828), Trans(0, 102, 1, 827)], k: 1, }, - /* 325 - "InterfaceGroup" */ + /* 330 - "InterfaceGroup" */ LookaheadDFA { - prod0: 807, + prod0: 837, transitions: &[], k: 0, }, - /* 326 - "InterfaceGroupGroup" */ + /* 331 - "InterfaceGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 2, 811), - Trans(0, 38, 1, 808), - Trans(0, 59, 2, 811), - Trans(0, 63, 2, 811), - Trans(0, 64, 2, 811), - Trans(0, 65, 2, 811), - Trans(0, 69, 2, 811), - Trans(0, 70, 2, 811), - Trans(0, 72, 2, 811), - Trans(0, 79, 2, 811), - Trans(0, 80, 2, 811), - Trans(0, 83, 2, 811), - Trans(0, 103, 2, 811), - Trans(0, 105, 2, 811), - Trans(0, 108, 2, 811), - Trans(0, 109, 2, 811), + Trans(0, 30, 2, 841), + Trans(0, 39, 1, 838), + Trans(0, 60, 2, 841), + Trans(0, 64, 2, 841), + Trans(0, 65, 2, 841), + Trans(0, 66, 2, 841), + Trans(0, 70, 2, 841), + Trans(0, 71, 2, 841), + Trans(0, 73, 2, 841), + Trans(0, 80, 2, 841), + Trans(0, 81, 2, 841), + Trans(0, 84, 2, 841), + Trans(0, 104, 2, 841), + Trans(0, 106, 2, 841), + Trans(0, 109, 2, 841), + Trans(0, 110, 2, 841), ], k: 1, }, - /* 327 - "InterfaceGroupGroupList" */ + /* 332 - "InterfaceGroupGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 809), - Trans(0, 35, 1, 809), - Trans(0, 38, 1, 809), - Trans(0, 42, 2, 810), - Trans(0, 59, 1, 809), - Trans(0, 63, 1, 809), - Trans(0, 64, 1, 809), - Trans(0, 65, 1, 809), - Trans(0, 69, 1, 809), - Trans(0, 70, 1, 809), - Trans(0, 72, 1, 809), - Trans(0, 79, 1, 809), - Trans(0, 80, 1, 809), - Trans(0, 83, 1, 809), - Trans(0, 103, 1, 809), - Trans(0, 105, 1, 809), - Trans(0, 108, 1, 809), - Trans(0, 109, 1, 809), + Trans(0, 30, 1, 839), + Trans(0, 36, 1, 839), + Trans(0, 39, 1, 839), + Trans(0, 43, 2, 840), + Trans(0, 60, 1, 839), + Trans(0, 64, 1, 839), + Trans(0, 65, 1, 839), + Trans(0, 66, 1, 839), + Trans(0, 70, 1, 839), + Trans(0, 71, 1, 839), + Trans(0, 73, 1, 839), + Trans(0, 80, 1, 839), + Trans(0, 81, 1, 839), + Trans(0, 84, 1, 839), + Trans(0, 104, 1, 839), + Trans(0, 106, 1, 839), + Trans(0, 109, 1, 839), + Trans(0, 110, 1, 839), ], k: 1, }, - /* 328 - "InterfaceGroupList" */ + /* 333 - "InterfaceGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 2, 813), - Trans(0, 35, 1, 812), - Trans(0, 38, 2, 813), - Trans(0, 59, 2, 813), - Trans(0, 63, 2, 813), - Trans(0, 64, 2, 813), - Trans(0, 65, 2, 813), - Trans(0, 69, 2, 813), - Trans(0, 70, 2, 813), - Trans(0, 72, 2, 813), - Trans(0, 79, 2, 813), - Trans(0, 80, 2, 813), - Trans(0, 83, 2, 813), - Trans(0, 103, 2, 813), - Trans(0, 105, 2, 813), - Trans(0, 108, 2, 813), - Trans(0, 109, 2, 813), + Trans(0, 30, 2, 843), + Trans(0, 36, 1, 842), + Trans(0, 39, 2, 843), + Trans(0, 60, 2, 843), + Trans(0, 64, 2, 843), + Trans(0, 65, 2, 843), + Trans(0, 66, 2, 843), + Trans(0, 70, 2, 843), + Trans(0, 71, 2, 843), + Trans(0, 73, 2, 843), + Trans(0, 80, 2, 843), + Trans(0, 81, 2, 843), + Trans(0, 84, 2, 843), + Trans(0, 104, 2, 843), + Trans(0, 106, 2, 843), + Trans(0, 109, 2, 843), + Trans(0, 110, 2, 843), ], k: 1, }, - /* 329 - "InterfaceIfDeclaration" */ + /* 334 - "InterfaceIfDeclaration" */ LookaheadDFA { - prod0: 791, + prod0: 821, transitions: &[], k: 0, }, - /* 330 - "InterfaceIfDeclarationList" */ + /* 335 - "InterfaceIfDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 5, -1), - Trans(0, 35, 6, -1), - Trans(0, 38, 7, -1), - Trans(0, 42, 8, -1), - Trans(0, 57, 1, -1), - Trans(0, 59, 9, -1), - Trans(0, 63, 10, -1), - Trans(0, 64, 11, -1), - Trans(0, 65, 12, -1), - Trans(0, 69, 13, -1), - Trans(0, 70, 14, -1), - Trans(0, 72, 10, -1), - Trans(0, 79, 9, -1), + Trans(0, 30, 5, -1), + Trans(0, 36, 6, -1), + Trans(0, 39, 7, -1), + Trans(0, 43, 8, -1), + Trans(0, 58, 1, -1), + Trans(0, 60, 9, -1), + Trans(0, 64, 10, -1), + Trans(0, 65, 11, -1), + Trans(0, 66, 12, -1), + Trans(0, 70, 13, -1), + Trans(0, 71, 14, -1), + Trans(0, 73, 10, -1), Trans(0, 80, 9, -1), - Trans(0, 83, 5, -1), - Trans(0, 103, 5, -1), - Trans(0, 105, 15, -1), - Trans(0, 108, 5, -1), - Trans(0, 109, 9, -1), + Trans(0, 81, 9, -1), + Trans(0, 84, 5, -1), + Trans(0, 104, 15, -1), + Trans(0, 106, 16, -1), + Trans(0, 109, 15, -1), + Trans(0, 110, 9, -1), Trans(1, 5, 4, -1), - Trans(1, 29, 18, -1), - Trans(1, 38, 33, -1), - Trans(1, 69, 2, -1), - Trans(2, 5, 3, 792), - Trans(2, 6, 3, 792), - Trans(2, 7, 3, 792), - Trans(2, 8, 3, 792), - Trans(2, 9, 3, 792), - Trans(2, 10, 3, 792), - Trans(2, 11, 3, 792), - Trans(2, 18, 3, 792), - Trans(2, 24, 3, 792), - Trans(2, 25, 3, 792), - Trans(2, 26, 3, 792), - Trans(2, 27, 3, 792), - Trans(2, 37, 3, 792), - Trans(2, 38, 3, 792), - Trans(2, 40, 3, 792), - Trans(2, 52, 3, 792), - Trans(2, 69, 3, 792), - Trans(2, 75, 3, 792), - Trans(2, 82, 3, 792), - Trans(2, 85, 3, 792), - Trans(2, 87, 3, 792), - Trans(2, 110, 3, 792), - Trans(2, 111, 3, 792), - Trans(4, 29, 16, 793), - Trans(4, 38, 16, 793), - Trans(4, 69, 3, 792), - Trans(5, 5, 39, -1), - Trans(5, 111, 24, -1), - Trans(6, 5, 36, -1), - Trans(6, 39, 18, -1), - Trans(7, 5, 32, -1), - Trans(7, 29, 18, -1), - Trans(7, 35, 19, -1), - Trans(7, 38, 33, -1), - Trans(7, 42, 33, -1), - Trans(7, 59, 18, -1), - Trans(7, 63, 24, -1), - Trans(7, 64, 18, -1), - Trans(7, 65, 18, -1), - Trans(7, 69, 25, -1), + Trans(1, 30, 19, -1), + Trans(1, 39, 35, -1), + Trans(1, 70, 2, -1), + Trans(2, 5, 3, 822), + Trans(2, 6, 3, 822), + Trans(2, 7, 3, 822), + Trans(2, 8, 3, 822), + Trans(2, 9, 3, 822), + Trans(2, 10, 3, 822), + Trans(2, 11, 3, 822), + Trans(2, 18, 3, 822), + Trans(2, 24, 3, 822), + Trans(2, 25, 3, 822), + Trans(2, 26, 3, 822), + Trans(2, 27, 3, 822), + Trans(2, 38, 3, 822), + Trans(2, 39, 3, 822), + Trans(2, 41, 3, 822), + Trans(2, 53, 3, 822), + Trans(2, 70, 3, 822), + Trans(2, 76, 3, 822), + Trans(2, 83, 3, 822), + Trans(2, 86, 3, 822), + Trans(2, 88, 3, 822), + Trans(2, 111, 3, 822), + Trans(2, 112, 3, 822), + Trans(4, 30, 17, 823), + Trans(4, 39, 17, 823), + Trans(4, 70, 3, 822), + Trans(5, 5, 42, -1), + Trans(5, 112, 25, -1), + Trans(6, 5, 38, -1), + Trans(6, 40, 19, -1), + Trans(7, 5, 34, -1), + Trans(7, 30, 19, -1), + Trans(7, 36, 20, -1), + Trans(7, 39, 35, -1), + Trans(7, 43, 35, -1), + Trans(7, 60, 19, -1), + Trans(7, 64, 25, -1), + Trans(7, 65, 19, -1), + Trans(7, 66, 19, -1), Trans(7, 70, 26, -1), - Trans(7, 72, 24, -1), - Trans(7, 79, 18, -1), - Trans(7, 80, 18, -1), - Trans(7, 83, 18, -1), - Trans(7, 103, 18, -1), - Trans(7, 105, 18, -1), - Trans(7, 108, 18, -1), - Trans(7, 109, 18, -1), - Trans(8, 0, 16, 793), - Trans(8, 5, 17, -1), - Trans(8, 29, 18, -1), - Trans(8, 35, 19, -1), - Trans(8, 38, 20, -1), - Trans(8, 42, 21, -1), - Trans(8, 57, 22, -1), + Trans(7, 71, 27, -1), + Trans(7, 73, 25, -1), + Trans(7, 80, 19, -1), + Trans(7, 81, 19, -1), + Trans(7, 84, 19, -1), + Trans(7, 104, 19, -1), + Trans(7, 106, 19, -1), + Trans(7, 109, 19, -1), + Trans(7, 110, 19, -1), + Trans(8, 0, 17, 823), + Trans(8, 5, 18, -1), + Trans(8, 30, 19, -1), + Trans(8, 36, 20, -1), + Trans(8, 39, 21, -1), + Trans(8, 43, 22, -1), Trans(8, 58, 23, -1), - Trans(8, 59, 18, -1), - Trans(8, 63, 24, -1), - Trans(8, 64, 18, -1), - Trans(8, 65, 18, -1), - Trans(8, 69, 25, -1), + Trans(8, 59, 24, -1), + Trans(8, 60, 19, -1), + Trans(8, 64, 25, -1), + Trans(8, 65, 19, -1), + Trans(8, 66, 19, -1), Trans(8, 70, 26, -1), - Trans(8, 71, 23, -1), + Trans(8, 71, 27, -1), Trans(8, 72, 24, -1), - Trans(8, 77, 18, -1), - Trans(8, 79, 18, -1), - Trans(8, 80, 18, -1), - Trans(8, 83, 18, -1), - Trans(8, 84, 18, -1), - Trans(8, 88, 18, -1), - Trans(8, 90, 27, -1), - Trans(8, 103, 18, -1), - Trans(8, 105, 18, -1), - Trans(8, 108, 18, -1), - Trans(8, 109, 18, -1), - Trans(9, 5, 39, -1), - Trans(9, 111, 40, -1), - Trans(10, 5, 34, -1), - Trans(10, 38, 35, -1), - Trans(11, 5, 39, -1), - Trans(11, 111, 41, -1), - Trans(12, 5, 39, -1), - Trans(12, 111, 42, -1), - Trans(13, 5, 28, -1), - Trans(13, 6, 29, -1), - Trans(13, 7, 29, -1), - Trans(13, 8, 29, -1), - Trans(13, 9, 29, -1), - Trans(13, 10, 29, -1), - Trans(13, 11, 29, -1), - Trans(13, 18, 25, -1), - Trans(13, 24, 25, -1), - Trans(13, 25, 25, -1), - Trans(13, 26, 25, -1), - Trans(13, 27, 25, -1), - Trans(13, 37, 30, -1), - Trans(13, 38, 25, -1), - Trans(13, 40, 25, -1), - Trans(13, 52, 25, -1), - Trans(13, 69, 25, -1), - Trans(13, 75, 25, -1), - Trans(13, 82, 29, -1), - Trans(13, 85, 29, -1), - Trans(13, 87, 25, -1), - Trans(13, 110, 31, -1), - Trans(13, 111, 31, -1), - Trans(14, 5, 37, -1), - Trans(14, 110, 38, -1), - Trans(14, 111, 38, -1), - Trans(15, 5, 39, -1), - Trans(15, 111, 43, -1), - Trans(17, 0, 16, 793), - Trans(17, 29, 16, 793), - Trans(17, 35, 16, 793), - Trans(17, 38, 16, 793), - Trans(17, 42, 16, 793), - Trans(17, 57, 16, 793), - Trans(17, 58, 16, 793), - Trans(17, 59, 16, 793), - Trans(17, 63, 16, 793), - Trans(17, 64, 16, 793), - Trans(17, 65, 16, 793), - Trans(17, 69, 16, 793), - Trans(17, 70, 16, 793), - Trans(17, 71, 16, 793), - Trans(17, 72, 16, 793), - Trans(17, 77, 16, 793), - Trans(17, 79, 16, 793), - Trans(17, 80, 16, 793), - Trans(17, 83, 16, 793), - Trans(17, 84, 16, 793), - Trans(17, 88, 16, 793), - Trans(17, 90, 16, 793), - Trans(17, 103, 16, 793), - Trans(17, 105, 16, 793), - Trans(17, 108, 16, 793), - Trans(17, 109, 16, 793), - Trans(18, 5, 16, 793), - Trans(18, 111, 16, 793), - Trans(19, 5, 16, 793), - Trans(19, 39, 16, 793), - Trans(20, 5, 16, 793), - Trans(20, 29, 16, 793), - Trans(20, 35, 16, 793), - Trans(20, 38, 16, 793), - Trans(20, 42, 16, 793), - Trans(20, 58, 16, 793), - Trans(20, 59, 16, 793), - Trans(20, 63, 16, 793), - Trans(20, 64, 16, 793), - Trans(20, 65, 16, 793), - Trans(20, 69, 16, 793), - Trans(20, 70, 16, 793), - Trans(20, 71, 16, 793), - Trans(20, 72, 16, 793), - Trans(20, 77, 16, 793), - Trans(20, 79, 16, 793), - Trans(20, 80, 16, 793), - Trans(20, 83, 16, 793), - Trans(20, 84, 16, 793), - Trans(20, 88, 16, 793), - Trans(20, 90, 16, 793), - Trans(20, 103, 16, 793), - Trans(20, 105, 16, 793), - Trans(20, 108, 16, 793), - Trans(20, 109, 16, 793), - Trans(21, 0, 16, 793), - Trans(21, 5, 16, 793), - Trans(21, 29, 16, 793), - Trans(21, 35, 16, 793), - Trans(21, 38, 16, 793), - Trans(21, 42, 16, 793), - Trans(21, 57, 16, 793), - Trans(21, 58, 16, 793), - Trans(21, 59, 16, 793), - Trans(21, 63, 16, 793), - Trans(21, 64, 16, 793), - Trans(21, 65, 16, 793), - Trans(21, 69, 16, 793), - Trans(21, 70, 16, 793), - Trans(21, 71, 16, 793), - Trans(21, 72, 16, 793), - Trans(21, 77, 16, 793), - Trans(21, 79, 16, 793), - Trans(21, 80, 16, 793), - Trans(21, 83, 16, 793), - Trans(21, 84, 16, 793), - Trans(21, 88, 16, 793), - Trans(21, 90, 16, 793), - Trans(21, 103, 16, 793), - Trans(21, 105, 16, 793), - Trans(21, 108, 16, 793), - Trans(21, 109, 16, 793), - Trans(22, 5, 16, 793), - Trans(22, 29, 16, 793), - Trans(22, 38, 16, 793), - Trans(22, 69, 16, 793), - Trans(23, 5, 16, 793), - Trans(23, 40, 16, 793), - Trans(24, 5, 16, 793), - Trans(24, 38, 16, 793), - Trans(25, 5, 16, 793), - Trans(25, 6, 16, 793), - Trans(25, 7, 16, 793), - Trans(25, 8, 16, 793), - Trans(25, 9, 16, 793), - Trans(25, 10, 16, 793), - Trans(25, 11, 16, 793), - Trans(25, 18, 16, 793), - Trans(25, 24, 16, 793), - Trans(25, 25, 16, 793), - Trans(25, 26, 16, 793), - Trans(25, 27, 16, 793), - Trans(25, 37, 16, 793), - Trans(25, 38, 16, 793), - Trans(25, 40, 16, 793), - Trans(25, 52, 16, 793), - Trans(25, 69, 16, 793), - Trans(25, 75, 16, 793), - Trans(25, 82, 16, 793), - Trans(25, 85, 16, 793), - Trans(25, 87, 16, 793), - Trans(25, 110, 16, 793), - Trans(25, 111, 16, 793), - Trans(26, 5, 16, 793), - Trans(26, 110, 16, 793), - Trans(26, 111, 16, 793), - Trans(27, 5, 16, 793), - Trans(27, 77, 16, 793), - Trans(27, 84, 16, 793), - Trans(27, 88, 16, 793), - Trans(28, 6, 16, 793), - Trans(28, 7, 16, 793), - Trans(28, 8, 16, 793), - Trans(28, 9, 16, 793), - Trans(28, 10, 16, 793), - Trans(28, 11, 16, 793), - Trans(28, 18, 16, 793), - Trans(28, 24, 16, 793), - Trans(28, 25, 16, 793), - Trans(28, 26, 16, 793), - Trans(28, 27, 16, 793), - Trans(28, 37, 16, 793), - Trans(28, 38, 16, 793), - Trans(28, 40, 16, 793), - Trans(28, 52, 16, 793), - Trans(28, 69, 16, 793), - Trans(28, 75, 16, 793), - Trans(28, 82, 16, 793), - Trans(28, 85, 16, 793), - Trans(28, 87, 16, 793), - Trans(28, 110, 16, 793), - Trans(28, 111, 16, 793), - Trans(29, 5, 16, 793), - Trans(29, 16, 16, 793), - Trans(29, 17, 16, 793), - Trans(29, 18, 16, 793), - Trans(29, 19, 16, 793), - Trans(29, 20, 16, 793), - Trans(29, 21, 16, 793), - Trans(29, 22, 16, 793), - Trans(29, 23, 16, 793), - Trans(29, 24, 16, 793), - Trans(29, 25, 16, 793), - Trans(29, 26, 16, 793), - Trans(29, 29, 16, 793), - Trans(29, 46, 16, 793), - Trans(29, 50, 16, 793), - Trans(30, 5, 16, 793), - Trans(30, 6, 16, 793), - Trans(30, 7, 16, 793), - Trans(30, 8, 16, 793), - Trans(30, 9, 16, 793), - Trans(30, 10, 16, 793), - Trans(30, 11, 16, 793), - Trans(30, 18, 16, 793), - Trans(30, 24, 16, 793), - Trans(30, 25, 16, 793), - Trans(30, 26, 16, 793), - Trans(30, 27, 16, 793), - Trans(30, 37, 16, 793), - Trans(30, 38, 16, 793), - Trans(30, 40, 16, 793), - Trans(30, 52, 16, 793), - Trans(30, 56, 16, 793), - Trans(30, 69, 16, 793), - Trans(30, 75, 16, 793), - Trans(30, 82, 16, 793), - Trans(30, 85, 16, 793), - Trans(30, 87, 16, 793), - Trans(30, 110, 16, 793), - Trans(30, 111, 16, 793), - Trans(31, 5, 16, 793), - Trans(31, 16, 16, 793), - Trans(31, 17, 16, 793), - Trans(31, 18, 16, 793), - Trans(31, 19, 16, 793), - Trans(31, 20, 16, 793), - Trans(31, 21, 16, 793), - Trans(31, 22, 16, 793), - Trans(31, 23, 16, 793), - Trans(31, 24, 16, 793), - Trans(31, 25, 16, 793), - Trans(31, 26, 16, 793), - Trans(31, 28, 16, 793), - Trans(31, 29, 16, 793), - Trans(31, 33, 16, 793), - Trans(31, 39, 16, 793), - Trans(31, 40, 16, 793), - Trans(31, 46, 16, 793), - Trans(31, 50, 16, 793), - Trans(32, 29, 16, 793), - Trans(32, 35, 16, 793), - Trans(32, 38, 16, 793), - Trans(32, 42, 16, 793), - Trans(32, 59, 16, 793), - Trans(32, 63, 16, 793), - Trans(32, 64, 16, 793), - Trans(32, 65, 16, 793), - Trans(32, 69, 16, 793), - Trans(32, 70, 16, 793), - Trans(32, 72, 16, 793), - Trans(32, 79, 16, 793), - Trans(32, 80, 16, 793), - Trans(32, 83, 16, 793), - Trans(32, 103, 16, 793), - Trans(32, 105, 16, 793), - Trans(32, 108, 16, 793), - Trans(32, 109, 16, 793), - Trans(33, 5, 16, 793), - Trans(33, 29, 16, 793), - Trans(33, 35, 16, 793), - Trans(33, 38, 16, 793), - Trans(33, 42, 16, 793), - Trans(33, 59, 16, 793), - Trans(33, 63, 16, 793), - Trans(33, 64, 16, 793), - Trans(33, 65, 16, 793), - Trans(33, 69, 16, 793), - Trans(33, 70, 16, 793), - Trans(33, 72, 16, 793), - Trans(33, 79, 16, 793), - Trans(33, 80, 16, 793), - Trans(33, 83, 16, 793), - Trans(33, 103, 16, 793), - Trans(33, 105, 16, 793), - Trans(33, 108, 16, 793), - Trans(33, 109, 16, 793), - Trans(34, 38, 16, 793), - Trans(35, 5, 16, 793), - Trans(35, 42, 16, 793), - Trans(35, 52, 16, 793), - Trans(35, 64, 16, 793), - Trans(35, 68, 16, 793), - Trans(35, 69, 16, 793), - Trans(35, 79, 16, 793), - Trans(35, 98, 16, 793), - Trans(35, 99, 16, 793), - Trans(35, 110, 16, 793), - Trans(35, 111, 16, 793), - Trans(36, 39, 16, 793), - Trans(37, 110, 16, 793), - Trans(37, 111, 16, 793), - Trans(38, 5, 16, 793), - Trans(38, 28, 16, 793), - Trans(38, 45, 16, 793), - Trans(39, 111, 16, 793), - Trans(40, 5, 16, 793), - Trans(40, 29, 16, 793), - Trans(41, 5, 16, 793), - Trans(41, 78, 16, 793), - Trans(42, 5, 16, 793), - Trans(42, 13, 16, 793), - Trans(42, 38, 16, 793), - Trans(42, 40, 16, 793), - Trans(43, 5, 16, 793), - Trans(43, 34, 16, 793), + Trans(8, 73, 25, -1), + Trans(8, 78, 19, -1), + Trans(8, 80, 19, -1), + Trans(8, 81, 19, -1), + Trans(8, 84, 19, -1), + Trans(8, 85, 19, -1), + Trans(8, 89, 19, -1), + Trans(8, 91, 28, -1), + Trans(8, 104, 19, -1), + Trans(8, 106, 19, -1), + Trans(8, 109, 19, -1), + Trans(8, 110, 19, -1), + Trans(9, 5, 42, -1), + Trans(9, 112, 43, -1), + Trans(10, 5, 36, -1), + Trans(10, 39, 37, -1), + Trans(11, 5, 42, -1), + Trans(11, 112, 44, -1), + Trans(12, 5, 42, -1), + Trans(12, 112, 45, -1), + Trans(13, 5, 29, -1), + Trans(13, 6, 30, -1), + Trans(13, 7, 30, -1), + Trans(13, 8, 30, -1), + Trans(13, 9, 30, -1), + Trans(13, 10, 30, -1), + Trans(13, 11, 30, -1), + Trans(13, 18, 26, -1), + Trans(13, 24, 26, -1), + Trans(13, 25, 26, -1), + Trans(13, 26, 26, -1), + Trans(13, 27, 26, -1), + Trans(13, 38, 31, -1), + Trans(13, 39, 26, -1), + Trans(13, 41, 26, -1), + Trans(13, 53, 26, -1), + Trans(13, 70, 26, -1), + Trans(13, 76, 26, -1), + Trans(13, 83, 30, -1), + Trans(13, 86, 30, -1), + Trans(13, 88, 26, -1), + Trans(13, 111, 32, -1), + Trans(13, 112, 33, -1), + Trans(14, 5, 39, -1), + Trans(14, 111, 40, -1), + Trans(14, 112, 41, -1), + Trans(15, 5, 42, -1), + Trans(15, 112, 46, -1), + Trans(16, 5, 42, -1), + Trans(16, 112, 47, -1), + Trans(18, 0, 17, 823), + Trans(18, 30, 17, 823), + Trans(18, 36, 17, 823), + Trans(18, 39, 17, 823), + Trans(18, 43, 17, 823), + Trans(18, 58, 17, 823), + Trans(18, 59, 17, 823), + Trans(18, 60, 17, 823), + Trans(18, 64, 17, 823), + Trans(18, 65, 17, 823), + Trans(18, 66, 17, 823), + Trans(18, 70, 17, 823), + Trans(18, 71, 17, 823), + Trans(18, 72, 17, 823), + Trans(18, 73, 17, 823), + Trans(18, 78, 17, 823), + Trans(18, 80, 17, 823), + Trans(18, 81, 17, 823), + Trans(18, 84, 17, 823), + Trans(18, 85, 17, 823), + Trans(18, 89, 17, 823), + Trans(18, 91, 17, 823), + Trans(18, 104, 17, 823), + Trans(18, 106, 17, 823), + Trans(18, 109, 17, 823), + Trans(18, 110, 17, 823), + Trans(19, 5, 17, 823), + Trans(19, 112, 17, 823), + Trans(20, 5, 17, 823), + Trans(20, 40, 17, 823), + Trans(21, 5, 17, 823), + Trans(21, 30, 17, 823), + Trans(21, 36, 17, 823), + Trans(21, 39, 17, 823), + Trans(21, 43, 17, 823), + Trans(21, 59, 17, 823), + Trans(21, 60, 17, 823), + Trans(21, 64, 17, 823), + Trans(21, 65, 17, 823), + Trans(21, 66, 17, 823), + Trans(21, 70, 17, 823), + Trans(21, 71, 17, 823), + Trans(21, 72, 17, 823), + Trans(21, 73, 17, 823), + Trans(21, 78, 17, 823), + Trans(21, 80, 17, 823), + Trans(21, 81, 17, 823), + Trans(21, 84, 17, 823), + Trans(21, 85, 17, 823), + Trans(21, 89, 17, 823), + Trans(21, 91, 17, 823), + Trans(21, 104, 17, 823), + Trans(21, 106, 17, 823), + Trans(21, 109, 17, 823), + Trans(21, 110, 17, 823), + Trans(22, 0, 17, 823), + Trans(22, 5, 17, 823), + Trans(22, 30, 17, 823), + Trans(22, 36, 17, 823), + Trans(22, 39, 17, 823), + Trans(22, 43, 17, 823), + Trans(22, 58, 17, 823), + Trans(22, 59, 17, 823), + Trans(22, 60, 17, 823), + Trans(22, 64, 17, 823), + Trans(22, 65, 17, 823), + Trans(22, 66, 17, 823), + Trans(22, 70, 17, 823), + Trans(22, 71, 17, 823), + Trans(22, 72, 17, 823), + Trans(22, 73, 17, 823), + Trans(22, 78, 17, 823), + Trans(22, 80, 17, 823), + Trans(22, 81, 17, 823), + Trans(22, 84, 17, 823), + Trans(22, 85, 17, 823), + Trans(22, 89, 17, 823), + Trans(22, 91, 17, 823), + Trans(22, 104, 17, 823), + Trans(22, 106, 17, 823), + Trans(22, 109, 17, 823), + Trans(22, 110, 17, 823), + Trans(23, 5, 17, 823), + Trans(23, 30, 17, 823), + Trans(23, 39, 17, 823), + Trans(23, 70, 17, 823), + Trans(24, 5, 17, 823), + Trans(24, 41, 17, 823), + Trans(25, 5, 17, 823), + Trans(25, 39, 17, 823), + Trans(26, 5, 17, 823), + Trans(26, 6, 17, 823), + Trans(26, 7, 17, 823), + Trans(26, 8, 17, 823), + Trans(26, 9, 17, 823), + Trans(26, 10, 17, 823), + Trans(26, 11, 17, 823), + Trans(26, 18, 17, 823), + Trans(26, 24, 17, 823), + Trans(26, 25, 17, 823), + Trans(26, 26, 17, 823), + Trans(26, 27, 17, 823), + Trans(26, 38, 17, 823), + Trans(26, 39, 17, 823), + Trans(26, 41, 17, 823), + Trans(26, 53, 17, 823), + Trans(26, 70, 17, 823), + Trans(26, 76, 17, 823), + Trans(26, 83, 17, 823), + Trans(26, 86, 17, 823), + Trans(26, 88, 17, 823), + Trans(26, 111, 17, 823), + Trans(26, 112, 17, 823), + Trans(27, 5, 17, 823), + Trans(27, 111, 17, 823), + Trans(27, 112, 17, 823), + Trans(28, 5, 17, 823), + Trans(28, 78, 17, 823), + Trans(28, 85, 17, 823), + Trans(28, 89, 17, 823), + Trans(29, 6, 17, 823), + Trans(29, 7, 17, 823), + Trans(29, 8, 17, 823), + Trans(29, 9, 17, 823), + Trans(29, 10, 17, 823), + Trans(29, 11, 17, 823), + Trans(29, 18, 17, 823), + Trans(29, 24, 17, 823), + Trans(29, 25, 17, 823), + Trans(29, 26, 17, 823), + Trans(29, 27, 17, 823), + Trans(29, 38, 17, 823), + Trans(29, 39, 17, 823), + Trans(29, 41, 17, 823), + Trans(29, 53, 17, 823), + Trans(29, 70, 17, 823), + Trans(29, 76, 17, 823), + Trans(29, 83, 17, 823), + Trans(29, 86, 17, 823), + Trans(29, 88, 17, 823), + Trans(29, 111, 17, 823), + Trans(29, 112, 17, 823), + Trans(30, 5, 17, 823), + Trans(30, 16, 17, 823), + Trans(30, 17, 17, 823), + Trans(30, 18, 17, 823), + Trans(30, 19, 17, 823), + Trans(30, 20, 17, 823), + Trans(30, 21, 17, 823), + Trans(30, 22, 17, 823), + Trans(30, 23, 17, 823), + Trans(30, 24, 17, 823), + Trans(30, 25, 17, 823), + Trans(30, 26, 17, 823), + Trans(30, 30, 17, 823), + Trans(30, 47, 17, 823), + Trans(30, 51, 17, 823), + Trans(31, 5, 17, 823), + Trans(31, 6, 17, 823), + Trans(31, 7, 17, 823), + Trans(31, 8, 17, 823), + Trans(31, 9, 17, 823), + Trans(31, 10, 17, 823), + Trans(31, 11, 17, 823), + Trans(31, 18, 17, 823), + Trans(31, 24, 17, 823), + Trans(31, 25, 17, 823), + Trans(31, 26, 17, 823), + Trans(31, 27, 17, 823), + Trans(31, 38, 17, 823), + Trans(31, 39, 17, 823), + Trans(31, 41, 17, 823), + Trans(31, 53, 17, 823), + Trans(31, 57, 17, 823), + Trans(31, 70, 17, 823), + Trans(31, 76, 17, 823), + Trans(31, 83, 17, 823), + Trans(31, 86, 17, 823), + Trans(31, 88, 17, 823), + Trans(31, 111, 17, 823), + Trans(31, 112, 17, 823), + Trans(32, 5, 17, 823), + Trans(32, 16, 17, 823), + Trans(32, 17, 17, 823), + Trans(32, 18, 17, 823), + Trans(32, 19, 17, 823), + Trans(32, 20, 17, 823), + Trans(32, 21, 17, 823), + Trans(32, 22, 17, 823), + Trans(32, 23, 17, 823), + Trans(32, 24, 17, 823), + Trans(32, 25, 17, 823), + Trans(32, 26, 17, 823), + Trans(32, 29, 17, 823), + Trans(32, 30, 17, 823), + Trans(32, 34, 17, 823), + Trans(32, 40, 17, 823), + Trans(32, 41, 17, 823), + Trans(32, 47, 17, 823), + Trans(32, 51, 17, 823), + Trans(33, 5, 17, 823), + Trans(33, 16, 17, 823), + Trans(33, 17, 17, 823), + Trans(33, 18, 17, 823), + Trans(33, 19, 17, 823), + Trans(33, 20, 17, 823), + Trans(33, 21, 17, 823), + Trans(33, 22, 17, 823), + Trans(33, 23, 17, 823), + Trans(33, 24, 17, 823), + Trans(33, 25, 17, 823), + Trans(33, 26, 17, 823), + Trans(33, 28, 17, 823), + Trans(33, 29, 17, 823), + Trans(33, 30, 17, 823), + Trans(33, 34, 17, 823), + Trans(33, 40, 17, 823), + Trans(33, 41, 17, 823), + Trans(33, 47, 17, 823), + Trans(33, 51, 17, 823), + Trans(34, 30, 17, 823), + Trans(34, 36, 17, 823), + Trans(34, 39, 17, 823), + Trans(34, 43, 17, 823), + Trans(34, 60, 17, 823), + Trans(34, 64, 17, 823), + Trans(34, 65, 17, 823), + Trans(34, 66, 17, 823), + Trans(34, 70, 17, 823), + Trans(34, 71, 17, 823), + Trans(34, 73, 17, 823), + Trans(34, 80, 17, 823), + Trans(34, 81, 17, 823), + Trans(34, 84, 17, 823), + Trans(34, 104, 17, 823), + Trans(34, 106, 17, 823), + Trans(34, 109, 17, 823), + Trans(34, 110, 17, 823), + Trans(35, 5, 17, 823), + Trans(35, 30, 17, 823), + Trans(35, 36, 17, 823), + Trans(35, 39, 17, 823), + Trans(35, 43, 17, 823), + Trans(35, 60, 17, 823), + Trans(35, 64, 17, 823), + Trans(35, 65, 17, 823), + Trans(35, 66, 17, 823), + Trans(35, 70, 17, 823), + Trans(35, 71, 17, 823), + Trans(35, 73, 17, 823), + Trans(35, 80, 17, 823), + Trans(35, 81, 17, 823), + Trans(35, 84, 17, 823), + Trans(35, 104, 17, 823), + Trans(35, 106, 17, 823), + Trans(35, 109, 17, 823), + Trans(35, 110, 17, 823), + Trans(36, 39, 17, 823), + Trans(37, 5, 17, 823), + Trans(37, 43, 17, 823), + Trans(37, 53, 17, 823), + Trans(37, 65, 17, 823), + Trans(37, 69, 17, 823), + Trans(37, 70, 17, 823), + Trans(37, 80, 17, 823), + Trans(37, 99, 17, 823), + Trans(37, 100, 17, 823), + Trans(37, 111, 17, 823), + Trans(37, 112, 17, 823), + Trans(38, 40, 17, 823), + Trans(39, 111, 17, 823), + Trans(39, 112, 17, 823), + Trans(40, 5, 17, 823), + Trans(40, 29, 17, 823), + Trans(40, 46, 17, 823), + Trans(41, 5, 17, 823), + Trans(41, 28, 17, 823), + Trans(41, 29, 17, 823), + Trans(41, 46, 17, 823), + Trans(42, 112, 17, 823), + Trans(43, 5, 17, 823), + Trans(43, 30, 17, 823), + Trans(44, 5, 17, 823), + Trans(44, 79, 17, 823), + Trans(45, 5, 17, 823), + Trans(45, 13, 17, 823), + Trans(45, 28, 17, 823), + Trans(45, 39, 17, 823), + Trans(45, 41, 17, 823), + Trans(46, 5, 17, 823), + Trans(46, 28, 17, 823), + Trans(46, 39, 17, 823), + Trans(47, 5, 17, 823), + Trans(47, 35, 17, 823), ], k: 3, }, - /* 331 - "InterfaceIfDeclarationOpt" */ + /* 336 - "InterfaceIfDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 2, 795), - Trans(0, 35, 2, 795), - Trans(0, 38, 2, 795), - Trans(0, 42, 2, 795), - Trans(0, 57, 1, 794), - Trans(0, 59, 2, 795), - Trans(0, 63, 2, 795), - Trans(0, 64, 2, 795), - Trans(0, 65, 2, 795), - Trans(0, 69, 2, 795), - Trans(0, 70, 2, 795), - Trans(0, 72, 2, 795), - Trans(0, 79, 2, 795), - Trans(0, 80, 2, 795), - Trans(0, 83, 2, 795), - Trans(0, 103, 2, 795), - Trans(0, 105, 2, 795), - Trans(0, 108, 2, 795), - Trans(0, 109, 2, 795), + Trans(0, 30, 2, 825), + Trans(0, 36, 2, 825), + Trans(0, 39, 2, 825), + Trans(0, 43, 2, 825), + Trans(0, 58, 1, 824), + Trans(0, 60, 2, 825), + Trans(0, 64, 2, 825), + Trans(0, 65, 2, 825), + Trans(0, 66, 2, 825), + Trans(0, 70, 2, 825), + Trans(0, 71, 2, 825), + Trans(0, 73, 2, 825), + Trans(0, 80, 2, 825), + Trans(0, 81, 2, 825), + Trans(0, 84, 2, 825), + Trans(0, 104, 2, 825), + Trans(0, 106, 2, 825), + Trans(0, 109, 2, 825), + Trans(0, 110, 2, 825), ], k: 1, }, - /* 332 - "InterfaceItem" */ + /* 337 - "InterfaceItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 10, 823), - Trans(0, 59, 8, 821), - Trans(0, 63, 14, 827), - Trans(0, 64, 6, 819), - Trans(0, 65, 11, 824), - Trans(0, 69, 5, 818), - Trans(0, 70, 12, 825), - Trans(0, 72, 13, 826), - Trans(0, 79, 1, 814), - Trans(0, 80, 3, 816), - Trans(0, 83, 4, 817), - Trans(0, 103, 9, 822), - Trans(0, 105, 7, 820), - Trans(0, 108, 9, 822), - Trans(0, 109, 2, 815), + Trans(0, 30, 10, 853), + Trans(0, 60, 8, 851), + Trans(0, 64, 14, 857), + Trans(0, 65, 6, 849), + Trans(0, 66, 11, 854), + Trans(0, 70, 5, 848), + Trans(0, 71, 12, 855), + Trans(0, 73, 13, 856), + Trans(0, 80, 1, 844), + Trans(0, 81, 3, 846), + Trans(0, 84, 4, 847), + Trans(0, 104, 9, 852), + Trans(0, 106, 7, 850), + Trans(0, 109, 9, 852), + Trans(0, 110, 2, 845), ], k: 1, }, - /* 333 - "InterfaceNamedBlock" */ + /* 338 - "InterfaceNamedBlock" */ LookaheadDFA { - prod0: 799, + prod0: 829, transitions: &[], k: 0, }, - /* 334 - "InterfaceNamedBlockList" */ + /* 339 - "InterfaceNamedBlockList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 800), - Trans(0, 35, 1, 800), - Trans(0, 38, 1, 800), - Trans(0, 42, 2, 801), - Trans(0, 59, 1, 800), - Trans(0, 63, 1, 800), - Trans(0, 64, 1, 800), - Trans(0, 65, 1, 800), - Trans(0, 69, 1, 800), - Trans(0, 70, 1, 800), - Trans(0, 72, 1, 800), - Trans(0, 79, 1, 800), - Trans(0, 80, 1, 800), - Trans(0, 83, 1, 800), - Trans(0, 103, 1, 800), - Trans(0, 105, 1, 800), - Trans(0, 108, 1, 800), - Trans(0, 109, 1, 800), + Trans(0, 30, 1, 830), + Trans(0, 36, 1, 830), + Trans(0, 39, 1, 830), + Trans(0, 43, 2, 831), + Trans(0, 60, 1, 830), + Trans(0, 64, 1, 830), + Trans(0, 65, 1, 830), + Trans(0, 66, 1, 830), + Trans(0, 70, 1, 830), + Trans(0, 71, 1, 830), + Trans(0, 73, 1, 830), + Trans(0, 80, 1, 830), + Trans(0, 81, 1, 830), + Trans(0, 84, 1, 830), + Trans(0, 104, 1, 830), + Trans(0, 106, 1, 830), + Trans(0, 109, 1, 830), + Trans(0, 110, 1, 830), ], k: 1, }, - /* 335 - "InterfaceOptionalNamedBlock" */ + /* 340 - "InterfaceOptionalNamedBlock" */ LookaheadDFA { - prod0: 802, + prod0: 832, transitions: &[], k: 0, }, - /* 336 - "InterfaceOptionalNamedBlockList" */ + /* 341 - "InterfaceOptionalNamedBlockList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 803), - Trans(0, 35, 1, 803), - Trans(0, 38, 1, 803), - Trans(0, 42, 2, 804), - Trans(0, 59, 1, 803), - Trans(0, 63, 1, 803), - Trans(0, 64, 1, 803), - Trans(0, 65, 1, 803), - Trans(0, 69, 1, 803), - Trans(0, 70, 1, 803), - Trans(0, 72, 1, 803), - Trans(0, 79, 1, 803), - Trans(0, 80, 1, 803), - Trans(0, 83, 1, 803), - Trans(0, 103, 1, 803), - Trans(0, 105, 1, 803), - Trans(0, 108, 1, 803), - Trans(0, 109, 1, 803), + Trans(0, 30, 1, 833), + Trans(0, 36, 1, 833), + Trans(0, 39, 1, 833), + Trans(0, 43, 2, 834), + Trans(0, 60, 1, 833), + Trans(0, 64, 1, 833), + Trans(0, 65, 1, 833), + Trans(0, 66, 1, 833), + Trans(0, 70, 1, 833), + Trans(0, 71, 1, 833), + Trans(0, 73, 1, 833), + Trans(0, 80, 1, 833), + Trans(0, 81, 1, 833), + Trans(0, 84, 1, 833), + Trans(0, 104, 1, 833), + Trans(0, 106, 1, 833), + Trans(0, 109, 1, 833), + Trans(0, 110, 1, 833), ], k: 1, }, - /* 337 - "InterfaceOptionalNamedBlockOpt" */ + /* 342 - "InterfaceOptionalNamedBlockOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 29, 1, 805), Trans(0, 38, 2, 806)], + transitions: &[Trans(0, 30, 1, 835), Trans(0, 39, 2, 836)], k: 1, }, - /* 338 - "InterfaceTerm" */ + /* 343 - "InterfaceTerm" */ LookaheadDFA { - prod0: 72, + prod0: 73, transitions: &[], k: 0, }, - /* 339 - "InterfaceToken" */ + /* 344 - "InterfaceToken" */ LookaheadDFA { - prod0: 183, + prod0: 185, transitions: &[], k: 0, }, - /* 340 - "LAngle" */ + /* 345 - "LAngle" */ LookaheadDFA { - prod0: 247, + prod0: 250, transitions: &[], k: 0, }, - /* 341 - "LAngleTerm" */ + /* 346 - "LAngleTerm" */ LookaheadDFA { - prod0: 31, + prod0: 32, transitions: &[], k: 0, }, - /* 342 - "LAngleToken" */ + /* 347 - "LAngleToken" */ LookaheadDFA { - prod0: 140, + prod0: 142, transitions: &[], k: 0, }, - /* 343 - "LBrace" */ + /* 348 - "LBrace" */ LookaheadDFA { - prod0: 248, + prod0: 251, transitions: &[], k: 0, }, - /* 344 - "LBraceTerm" */ + /* 349 - "LBraceTerm" */ LookaheadDFA { - prod0: 33, + prod0: 34, transitions: &[], k: 0, }, - /* 345 - "LBraceToken" */ + /* 350 - "LBraceToken" */ LookaheadDFA { - prod0: 141, + prod0: 143, transitions: &[], k: 0, }, - /* 346 - "LBracket" */ + /* 351 - "LBracket" */ LookaheadDFA { - prod0: 249, + prod0: 252, transitions: &[], k: 0, }, - /* 347 - "LBracketTerm" */ + /* 352 - "LBracketTerm" */ LookaheadDFA { - prod0: 34, + prod0: 35, transitions: &[], k: 0, }, - /* 348 - "LBracketToken" */ + /* 353 - "LBracketToken" */ LookaheadDFA { - prod0: 142, + prod0: 144, transitions: &[], k: 0, }, - /* 349 - "LParen" */ + /* 354 - "LParen" */ LookaheadDFA { - prod0: 250, + prod0: 253, transitions: &[], k: 0, }, - /* 350 - "LParenTerm" */ + /* 355 - "LParenTerm" */ LookaheadDFA { - prod0: 35, + prod0: 36, transitions: &[], k: 0, }, - /* 351 - "LParenToken" */ + /* 356 - "LParenToken" */ LookaheadDFA { - prod0: 143, + prod0: 145, transitions: &[], k: 0, }, - /* 352 - "Let" */ + /* 357 - "Let" */ LookaheadDFA { - prod0: 293, + prod0: 296, transitions: &[], k: 0, }, - /* 353 - "LetDeclaration" */ + /* 358 - "LetDeclaration" */ LookaheadDFA { - prod0: 576, + prod0: 583, transitions: &[], k: 0, }, - /* 354 - "LetStatement" */ + /* 359 - "LetStatement" */ LookaheadDFA { - prod0: 518, + prod0: 525, transitions: &[], k: 0, }, - /* 355 - "LetTerm" */ + /* 360 - "LetTerm" */ LookaheadDFA { - prod0: 74, + prod0: 75, transitions: &[], k: 0, }, - /* 356 - "LetToken" */ + /* 361 - "LetToken" */ LookaheadDFA { - prod0: 185, + prod0: 187, transitions: &[], k: 0, }, - /* 357 - "Local" */ + /* 362 - "Local" */ LookaheadDFA { - prod0: 294, + prod0: 297, transitions: &[], k: 0, }, - /* 358 - "LocalDeclaration" */ + /* 363 - "LocalDeclaration" */ LookaheadDFA { - prod0: 578, + prod0: 585, transitions: &[], k: 0, }, - /* 359 - "LocalDeclarationGroup" */ + /* 364 - "LocalDeclarationGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 51, 1, 579), - Trans(0, 53, 1, 579), - Trans(0, 54, 1, 579), - Trans(0, 55, 1, 579), - Trans(0, 61, 1, 579), - Trans(0, 62, 1, 579), - Trans(0, 66, 1, 579), - Trans(0, 67, 1, 579), - Trans(0, 81, 1, 579), - Trans(0, 93, 1, 579), - Trans(0, 94, 1, 579), - Trans(0, 95, 1, 579), - Trans(0, 96, 1, 579), - Trans(0, 97, 1, 579), - Trans(0, 100, 1, 579), - Trans(0, 102, 1, 579), - Trans(0, 104, 1, 579), - Trans(0, 105, 2, 580), - Trans(0, 106, 1, 579), - Trans(0, 107, 1, 579), - Trans(0, 110, 1, 579), - Trans(0, 111, 1, 579), + Trans(0, 52, 1, 586), + Trans(0, 54, 1, 586), + Trans(0, 55, 1, 586), + Trans(0, 56, 1, 586), + Trans(0, 62, 1, 586), + Trans(0, 63, 1, 586), + Trans(0, 67, 1, 586), + Trans(0, 68, 1, 586), + Trans(0, 82, 1, 586), + Trans(0, 94, 1, 586), + Trans(0, 95, 1, 586), + Trans(0, 96, 1, 586), + Trans(0, 97, 1, 586), + Trans(0, 98, 1, 586), + Trans(0, 101, 1, 586), + Trans(0, 103, 1, 586), + Trans(0, 105, 1, 586), + Trans(0, 106, 2, 587), + Trans(0, 107, 1, 586), + Trans(0, 108, 1, 586), + Trans(0, 111, 1, 586), + Trans(0, 112, 1, 586), ], k: 1, }, - /* 360 - "LocalTerm" */ + /* 365 - "LocalTerm" */ LookaheadDFA { - prod0: 75, + prod0: 76, transitions: &[], k: 0, }, - /* 361 - "LocalToken" */ + /* 366 - "LocalToken" */ LookaheadDFA { - prod0: 186, + prod0: 188, transitions: &[], k: 0, }, - /* 362 - "Logic" */ + /* 367 - "Logic" */ LookaheadDFA { - prod0: 295, + prod0: 298, transitions: &[], k: 0, }, - /* 363 - "LogicTerm" */ + /* 368 - "LogicTerm" */ LookaheadDFA { - prod0: 76, + prod0: 77, transitions: &[], k: 0, }, - /* 364 - "LogicToken" */ + /* 369 - "LogicToken" */ LookaheadDFA { - prod0: 187, + prod0: 189, transitions: &[], k: 0, }, - /* 365 - "Lsb" */ + /* 370 - "Lsb" */ LookaheadDFA { - prod0: 296, + prod0: 299, transitions: &[], k: 0, }, - /* 366 - "LsbTerm" */ + /* 371 - "LsbTerm" */ LookaheadDFA { - prod0: 77, + prod0: 78, transitions: &[], k: 0, }, - /* 367 - "LsbToken" */ + /* 372 - "LsbToken" */ LookaheadDFA { - prod0: 188, + prod0: 190, transitions: &[], k: 0, }, - /* 368 - "MinusColon" */ + /* 373 - "MinusColon" */ LookaheadDFA { - prod0: 251, + prod0: 254, transitions: &[], k: 0, }, - /* 369 - "MinusColonTerm" */ + /* 374 - "MinusColonTerm" */ LookaheadDFA { prod0: 7, transitions: &[], k: 0, }, - /* 370 - "MinusColonToken" */ + /* 375 - "MinusColonToken" */ LookaheadDFA { - prod0: 144, + prod0: 146, transitions: &[], k: 0, }, - /* 371 - "MinusGT" */ + /* 376 - "MinusGT" */ LookaheadDFA { - prod0: 252, + prod0: 255, transitions: &[], k: 0, }, - /* 372 - "MinusGTTerm" */ + /* 377 - "MinusGTTerm" */ LookaheadDFA { prod0: 8, transitions: &[], k: 0, }, - /* 373 - "MinusGTToken" */ + /* 378 - "MinusGTToken" */ LookaheadDFA { - prod0: 145, + prod0: 147, transitions: &[], k: 0, }, - /* 374 - "Modport" */ + /* 379 - "Modport" */ LookaheadDFA { - prod0: 297, + prod0: 300, transitions: &[], k: 0, }, - /* 375 - "ModportDeclaration" */ + /* 380 - "ModportDeclaration" */ LookaheadDFA { - prod0: 593, + prod0: 600, transitions: &[], k: 0, }, - /* 376 - "ModportGroup" */ + /* 381 - "ModportGroup" */ LookaheadDFA { - prod0: 599, + prod0: 606, transitions: &[], k: 0, }, - /* 377 - "ModportGroupGroup" */ + /* 382 - "ModportGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 38, 1, 600), Trans(0, 111, 2, 601)], + transitions: &[Trans(0, 39, 1, 607), Trans(0, 112, 2, 608)], k: 1, }, - /* 378 - "ModportGroupList" */ + /* 383 - "ModportGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 602), - Trans(0, 38, 2, 603), - Trans(0, 111, 2, 603), + Trans(0, 36, 1, 609), + Trans(0, 39, 2, 610), + Trans(0, 112, 2, 610), ], k: 1, }, - /* 379 - "ModportItem" */ + /* 384 - "ModportItem" */ LookaheadDFA { - prod0: 604, + prod0: 611, transitions: &[], k: 0, }, - /* 380 - "ModportList" */ + /* 385 - "ModportList" */ LookaheadDFA { - prod0: 594, + prod0: 601, transitions: &[], k: 0, }, - /* 381 - "ModportListList" */ + /* 386 - "ModportListList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 7, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 7, -1), Trans(1, 5, 6, -1), - Trans(1, 35, 2, -1), - Trans(1, 38, 4, -1), - Trans(1, 42, 18, -1), - Trans(1, 111, 5, -1), - Trans(2, 5, 3, 595), - Trans(2, 39, 3, 595), - Trans(4, 5, 3, 595), - Trans(4, 35, 3, 595), - Trans(4, 38, 3, 595), - Trans(4, 111, 3, 595), - Trans(5, 5, 3, 595), - Trans(5, 29, 3, 595), - Trans(6, 35, 3, 595), - Trans(6, 38, 3, 595), - Trans(6, 42, 17, 596), - Trans(6, 111, 3, 595), + Trans(1, 36, 2, -1), + Trans(1, 39, 4, -1), + Trans(1, 43, 18, -1), + Trans(1, 112, 5, -1), + Trans(2, 5, 3, 602), + Trans(2, 40, 3, 602), + Trans(4, 5, 3, 602), + Trans(4, 36, 3, 602), + Trans(4, 39, 3, 602), + Trans(4, 112, 3, 602), + Trans(5, 5, 3, 602), + Trans(5, 30, 3, 602), + Trans(6, 36, 3, 602), + Trans(6, 39, 3, 602), + Trans(6, 43, 17, 603), + Trans(6, 112, 3, 602), Trans(7, 5, 8, -1), - Trans(7, 29, 9, -1), - Trans(7, 30, 10, -1), - Trans(7, 35, 11, -1), - Trans(7, 38, 12, -1), - Trans(7, 42, 13, -1), - Trans(7, 59, 9, -1), - Trans(7, 63, 14, -1), - Trans(7, 64, 9, -1), + Trans(7, 30, 9, -1), + Trans(7, 31, 10, -1), + Trans(7, 36, 11, -1), + Trans(7, 39, 12, -1), + Trans(7, 43, 13, -1), + Trans(7, 60, 9, -1), + Trans(7, 64, 14, -1), Trans(7, 65, 9, -1), - Trans(7, 69, 15, -1), - Trans(7, 70, 16, -1), - Trans(7, 72, 14, -1), - Trans(7, 79, 9, -1), + Trans(7, 66, 9, -1), + Trans(7, 70, 15, -1), + Trans(7, 71, 16, -1), + Trans(7, 73, 14, -1), Trans(7, 80, 9, -1), - Trans(7, 83, 9, -1), - Trans(7, 103, 9, -1), - Trans(7, 105, 9, -1), - Trans(7, 108, 9, -1), + Trans(7, 81, 9, -1), + Trans(7, 84, 9, -1), + Trans(7, 104, 9, -1), + Trans(7, 106, 9, -1), Trans(7, 109, 9, -1), - Trans(8, 29, 17, 596), - Trans(8, 30, 17, 596), - Trans(8, 35, 17, 596), - Trans(8, 38, 17, 596), - Trans(8, 42, 17, 596), - Trans(8, 59, 17, 596), - Trans(8, 63, 17, 596), - Trans(8, 64, 17, 596), - Trans(8, 65, 17, 596), - Trans(8, 69, 17, 596), - Trans(8, 70, 17, 596), - Trans(8, 72, 17, 596), - Trans(8, 79, 17, 596), - Trans(8, 80, 17, 596), - Trans(8, 83, 17, 596), - Trans(8, 103, 17, 596), - Trans(8, 105, 17, 596), - Trans(8, 108, 17, 596), - Trans(8, 109, 17, 596), - Trans(9, 5, 17, 596), - Trans(9, 111, 17, 596), - Trans(10, 5, 17, 596), - Trans(10, 35, 17, 596), - Trans(10, 38, 17, 596), - Trans(10, 42, 17, 596), - Trans(10, 111, 17, 596), - Trans(11, 5, 17, 596), - Trans(11, 39, 17, 596), - Trans(12, 5, 17, 596), - Trans(12, 29, 17, 596), - Trans(12, 35, 17, 596), - Trans(12, 38, 17, 596), - Trans(12, 42, 17, 596), - Trans(12, 59, 17, 596), - Trans(12, 63, 17, 596), - Trans(12, 64, 17, 596), - Trans(12, 65, 17, 596), - Trans(12, 69, 17, 596), - Trans(12, 70, 17, 596), - Trans(12, 72, 17, 596), - Trans(12, 79, 17, 596), - Trans(12, 80, 17, 596), - Trans(12, 83, 17, 596), - Trans(12, 103, 17, 596), - Trans(12, 105, 17, 596), - Trans(12, 108, 17, 596), - Trans(12, 109, 17, 596), - Trans(13, 0, 17, 596), - Trans(13, 5, 17, 596), - Trans(13, 29, 17, 596), - Trans(13, 30, 17, 596), - Trans(13, 35, 17, 596), - Trans(13, 38, 17, 596), - Trans(13, 42, 17, 596), - Trans(13, 57, 17, 596), - Trans(13, 58, 17, 596), - Trans(13, 59, 17, 596), - Trans(13, 63, 17, 596), - Trans(13, 64, 17, 596), - Trans(13, 65, 17, 596), - Trans(13, 69, 17, 596), - Trans(13, 70, 17, 596), - Trans(13, 71, 17, 596), - Trans(13, 72, 17, 596), - Trans(13, 77, 17, 596), - Trans(13, 79, 17, 596), - Trans(13, 80, 17, 596), - Trans(13, 83, 17, 596), - Trans(13, 84, 17, 596), - Trans(13, 88, 17, 596), - Trans(13, 90, 17, 596), - Trans(13, 103, 17, 596), - Trans(13, 105, 17, 596), - Trans(13, 108, 17, 596), - Trans(13, 109, 17, 596), - Trans(14, 5, 17, 596), - Trans(14, 38, 17, 596), - Trans(15, 5, 17, 596), - Trans(15, 6, 17, 596), - Trans(15, 7, 17, 596), - Trans(15, 8, 17, 596), - Trans(15, 9, 17, 596), - Trans(15, 10, 17, 596), - Trans(15, 11, 17, 596), - Trans(15, 18, 17, 596), - Trans(15, 24, 17, 596), - Trans(15, 25, 17, 596), - Trans(15, 26, 17, 596), - Trans(15, 27, 17, 596), - Trans(15, 37, 17, 596), - Trans(15, 38, 17, 596), - Trans(15, 40, 17, 596), - Trans(15, 52, 17, 596), - Trans(15, 69, 17, 596), - Trans(15, 75, 17, 596), - Trans(15, 82, 17, 596), - Trans(15, 85, 17, 596), - Trans(15, 87, 17, 596), - Trans(15, 110, 17, 596), - Trans(15, 111, 17, 596), - Trans(16, 5, 17, 596), - Trans(16, 110, 17, 596), - Trans(16, 111, 17, 596), - Trans(18, 5, 17, 596), - Trans(18, 29, 17, 596), - Trans(18, 30, 17, 596), - Trans(18, 35, 17, 596), - Trans(18, 38, 17, 596), - Trans(18, 42, 17, 596), - Trans(18, 59, 17, 596), - Trans(18, 63, 17, 596), - Trans(18, 64, 17, 596), - Trans(18, 65, 17, 596), - Trans(18, 69, 17, 596), - Trans(18, 70, 17, 596), - Trans(18, 72, 17, 596), - Trans(18, 79, 17, 596), - Trans(18, 80, 17, 596), - Trans(18, 83, 17, 596), - Trans(18, 103, 17, 596), - Trans(18, 105, 17, 596), - Trans(18, 108, 17, 596), - Trans(18, 109, 17, 596), + Trans(7, 110, 9, -1), + Trans(8, 30, 17, 603), + Trans(8, 31, 17, 603), + Trans(8, 36, 17, 603), + Trans(8, 39, 17, 603), + Trans(8, 43, 17, 603), + Trans(8, 60, 17, 603), + Trans(8, 64, 17, 603), + Trans(8, 65, 17, 603), + Trans(8, 66, 17, 603), + Trans(8, 70, 17, 603), + Trans(8, 71, 17, 603), + Trans(8, 73, 17, 603), + Trans(8, 80, 17, 603), + Trans(8, 81, 17, 603), + Trans(8, 84, 17, 603), + Trans(8, 104, 17, 603), + Trans(8, 106, 17, 603), + Trans(8, 109, 17, 603), + Trans(8, 110, 17, 603), + Trans(9, 5, 17, 603), + Trans(9, 112, 17, 603), + Trans(10, 5, 17, 603), + Trans(10, 36, 17, 603), + Trans(10, 39, 17, 603), + Trans(10, 43, 17, 603), + Trans(10, 112, 17, 603), + Trans(11, 5, 17, 603), + Trans(11, 40, 17, 603), + Trans(12, 5, 17, 603), + Trans(12, 30, 17, 603), + Trans(12, 36, 17, 603), + Trans(12, 39, 17, 603), + Trans(12, 43, 17, 603), + Trans(12, 60, 17, 603), + Trans(12, 64, 17, 603), + Trans(12, 65, 17, 603), + Trans(12, 66, 17, 603), + Trans(12, 70, 17, 603), + Trans(12, 71, 17, 603), + Trans(12, 73, 17, 603), + Trans(12, 80, 17, 603), + Trans(12, 81, 17, 603), + Trans(12, 84, 17, 603), + Trans(12, 104, 17, 603), + Trans(12, 106, 17, 603), + Trans(12, 109, 17, 603), + Trans(12, 110, 17, 603), + Trans(13, 0, 17, 603), + Trans(13, 5, 17, 603), + Trans(13, 30, 17, 603), + Trans(13, 31, 17, 603), + Trans(13, 36, 17, 603), + Trans(13, 39, 17, 603), + Trans(13, 43, 17, 603), + Trans(13, 58, 17, 603), + Trans(13, 59, 17, 603), + Trans(13, 60, 17, 603), + Trans(13, 64, 17, 603), + Trans(13, 65, 17, 603), + Trans(13, 66, 17, 603), + Trans(13, 70, 17, 603), + Trans(13, 71, 17, 603), + Trans(13, 72, 17, 603), + Trans(13, 73, 17, 603), + Trans(13, 78, 17, 603), + Trans(13, 80, 17, 603), + Trans(13, 81, 17, 603), + Trans(13, 84, 17, 603), + Trans(13, 85, 17, 603), + Trans(13, 89, 17, 603), + Trans(13, 91, 17, 603), + Trans(13, 104, 17, 603), + Trans(13, 106, 17, 603), + Trans(13, 109, 17, 603), + Trans(13, 110, 17, 603), + Trans(14, 5, 17, 603), + Trans(14, 39, 17, 603), + Trans(15, 5, 17, 603), + Trans(15, 6, 17, 603), + Trans(15, 7, 17, 603), + Trans(15, 8, 17, 603), + Trans(15, 9, 17, 603), + Trans(15, 10, 17, 603), + Trans(15, 11, 17, 603), + Trans(15, 18, 17, 603), + Trans(15, 24, 17, 603), + Trans(15, 25, 17, 603), + Trans(15, 26, 17, 603), + Trans(15, 27, 17, 603), + Trans(15, 38, 17, 603), + Trans(15, 39, 17, 603), + Trans(15, 41, 17, 603), + Trans(15, 53, 17, 603), + Trans(15, 70, 17, 603), + Trans(15, 76, 17, 603), + Trans(15, 83, 17, 603), + Trans(15, 86, 17, 603), + Trans(15, 88, 17, 603), + Trans(15, 111, 17, 603), + Trans(15, 112, 17, 603), + Trans(16, 5, 17, 603), + Trans(16, 111, 17, 603), + Trans(16, 112, 17, 603), + Trans(18, 5, 17, 603), + Trans(18, 30, 17, 603), + Trans(18, 31, 17, 603), + Trans(18, 36, 17, 603), + Trans(18, 39, 17, 603), + Trans(18, 43, 17, 603), + Trans(18, 60, 17, 603), + Trans(18, 64, 17, 603), + Trans(18, 65, 17, 603), + Trans(18, 66, 17, 603), + Trans(18, 70, 17, 603), + Trans(18, 71, 17, 603), + Trans(18, 73, 17, 603), + Trans(18, 80, 17, 603), + Trans(18, 81, 17, 603), + Trans(18, 84, 17, 603), + Trans(18, 104, 17, 603), + Trans(18, 106, 17, 603), + Trans(18, 109, 17, 603), + Trans(18, 110, 17, 603), ], k: 3, }, - /* 382 - "ModportListOpt" */ + /* 387 - "ModportListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 597), Trans(0, 42, 2, 598)], + transitions: &[Trans(0, 31, 1, 604), Trans(0, 43, 2, 605)], k: 1, }, - /* 383 - "ModportTerm" */ + /* 388 - "ModportTerm" */ LookaheadDFA { - prod0: 78, + prod0: 79, transitions: &[], k: 0, }, - /* 384 - "ModportToken" */ + /* 389 - "ModportToken" */ LookaheadDFA { - prod0: 189, + prod0: 191, transitions: &[], k: 0, }, - /* 385 - "Module" */ + /* 390 - "Module" */ LookaheadDFA { - prod0: 298, + prod0: 301, transitions: &[], k: 0, }, - /* 386 - "ModuleDeclaration" */ + /* 391 - "ModuleDeclaration" */ LookaheadDFA { - prod0: 735, + prod0: 761, transitions: &[], k: 0, }, - /* 387 - "ModuleDeclarationList" */ + /* 392 - "ModuleDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 736), - Trans(0, 35, 1, 736), - Trans(0, 38, 1, 736), - Trans(0, 42, 2, 737), - Trans(0, 47, 1, 736), - Trans(0, 48, 1, 736), - Trans(0, 49, 1, 736), - Trans(0, 59, 1, 736), - Trans(0, 63, 1, 736), - Trans(0, 64, 1, 736), - Trans(0, 65, 1, 736), - Trans(0, 69, 1, 736), - Trans(0, 70, 1, 736), - Trans(0, 72, 1, 736), - Trans(0, 76, 1, 736), - Trans(0, 79, 1, 736), - Trans(0, 80, 1, 736), - Trans(0, 103, 1, 736), - Trans(0, 105, 1, 736), - Trans(0, 108, 1, 736), - Trans(0, 109, 1, 736), + Trans(0, 30, 1, 762), + Trans(0, 36, 1, 762), + Trans(0, 39, 1, 762), + Trans(0, 43, 2, 763), + Trans(0, 48, 1, 762), + Trans(0, 49, 1, 762), + Trans(0, 50, 1, 762), + Trans(0, 60, 1, 762), + Trans(0, 64, 1, 762), + Trans(0, 65, 1, 762), + Trans(0, 66, 1, 762), + Trans(0, 70, 1, 762), + Trans(0, 71, 1, 762), + Trans(0, 73, 1, 762), + Trans(0, 77, 1, 762), + Trans(0, 80, 1, 762), + Trans(0, 81, 1, 762), + Trans(0, 104, 1, 762), + Trans(0, 106, 1, 762), + Trans(0, 109, 1, 762), + Trans(0, 110, 1, 762), ], k: 1, }, - /* 388 - "ModuleDeclarationOpt" */ + /* 393 - "ModuleDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 84, 2, 743), Trans(0, 90, 1, 742)], + transitions: &[Trans(0, 85, 2, 771), Trans(0, 91, 1, 770)], k: 1, }, - /* 389 - "ModuleDeclarationOpt0" */ + /* 394 - "ModuleDeclarationOpt0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 740), - Trans(0, 38, 2, 741), - Trans(0, 40, 2, 741), + Trans(0, 28, 1, 768), + Trans(0, 36, 2, 769), + Trans(0, 39, 2, 769), + Trans(0, 41, 2, 769), ], k: 1, }, - /* 390 - "ModuleDeclarationOpt1" */ + /* 395 - "ModuleDeclarationOpt1" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 38, 2, 739), Trans(0, 40, 1, 738)], + transitions: &[ + Trans(0, 36, 1, 766), + Trans(0, 39, 2, 767), + Trans(0, 41, 2, 767), + ], + k: 1, + }, + /* 396 - "ModuleDeclarationOpt2" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 39, 2, 765), Trans(0, 41, 1, 764)], k: 1, }, - /* 391 - "ModuleForDeclaration" */ + /* 397 - "ModuleForDeclaration" */ LookaheadDFA { - prod0: 749, + prod0: 777, transitions: &[], k: 0, }, - /* 392 - "ModuleForDeclarationOpt" */ + /* 398 - "ModuleForDeclarationOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 29, 2, 751), Trans(0, 101, 1, 750)], + transitions: &[Trans(0, 30, 2, 779), Trans(0, 102, 1, 778)], k: 1, }, - /* 393 - "ModuleGroup" */ + /* 399 - "ModuleGroup" */ LookaheadDFA { - prod0: 760, + prod0: 788, transitions: &[], k: 0, }, - /* 394 - "ModuleGroupGroup" */ + /* 400 - "ModuleGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 2, 764), - Trans(0, 38, 1, 761), - Trans(0, 47, 2, 764), - Trans(0, 48, 2, 764), - Trans(0, 49, 2, 764), - Trans(0, 59, 2, 764), - Trans(0, 63, 2, 764), - Trans(0, 64, 2, 764), - Trans(0, 65, 2, 764), - Trans(0, 69, 2, 764), - Trans(0, 70, 2, 764), - Trans(0, 72, 2, 764), - Trans(0, 76, 2, 764), - Trans(0, 79, 2, 764), - Trans(0, 80, 2, 764), - Trans(0, 103, 2, 764), - Trans(0, 105, 2, 764), - Trans(0, 108, 2, 764), - Trans(0, 109, 2, 764), + Trans(0, 30, 2, 792), + Trans(0, 39, 1, 789), + Trans(0, 48, 2, 792), + Trans(0, 49, 2, 792), + Trans(0, 50, 2, 792), + Trans(0, 60, 2, 792), + Trans(0, 64, 2, 792), + Trans(0, 65, 2, 792), + Trans(0, 66, 2, 792), + Trans(0, 70, 2, 792), + Trans(0, 71, 2, 792), + Trans(0, 73, 2, 792), + Trans(0, 77, 2, 792), + Trans(0, 80, 2, 792), + Trans(0, 81, 2, 792), + Trans(0, 104, 2, 792), + Trans(0, 106, 2, 792), + Trans(0, 109, 2, 792), + Trans(0, 110, 2, 792), ], k: 1, }, - /* 395 - "ModuleGroupGroupList" */ + /* 401 - "ModuleGroupGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 762), - Trans(0, 35, 1, 762), - Trans(0, 38, 1, 762), - Trans(0, 42, 2, 763), - Trans(0, 47, 1, 762), - Trans(0, 48, 1, 762), - Trans(0, 49, 1, 762), - Trans(0, 59, 1, 762), - Trans(0, 63, 1, 762), - Trans(0, 64, 1, 762), - Trans(0, 65, 1, 762), - Trans(0, 69, 1, 762), - Trans(0, 70, 1, 762), - Trans(0, 72, 1, 762), - Trans(0, 76, 1, 762), - Trans(0, 79, 1, 762), - Trans(0, 80, 1, 762), - Trans(0, 103, 1, 762), - Trans(0, 105, 1, 762), - Trans(0, 108, 1, 762), - Trans(0, 109, 1, 762), + Trans(0, 30, 1, 790), + Trans(0, 36, 1, 790), + Trans(0, 39, 1, 790), + Trans(0, 43, 2, 791), + Trans(0, 48, 1, 790), + Trans(0, 49, 1, 790), + Trans(0, 50, 1, 790), + Trans(0, 60, 1, 790), + Trans(0, 64, 1, 790), + Trans(0, 65, 1, 790), + Trans(0, 66, 1, 790), + Trans(0, 70, 1, 790), + Trans(0, 71, 1, 790), + Trans(0, 73, 1, 790), + Trans(0, 77, 1, 790), + Trans(0, 80, 1, 790), + Trans(0, 81, 1, 790), + Trans(0, 104, 1, 790), + Trans(0, 106, 1, 790), + Trans(0, 109, 1, 790), + Trans(0, 110, 1, 790), ], k: 1, }, - /* 396 - "ModuleGroupList" */ + /* 402 - "ModuleGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 2, 766), - Trans(0, 35, 1, 765), - Trans(0, 38, 2, 766), - Trans(0, 47, 2, 766), - Trans(0, 48, 2, 766), - Trans(0, 49, 2, 766), - Trans(0, 59, 2, 766), - Trans(0, 63, 2, 766), - Trans(0, 64, 2, 766), - Trans(0, 65, 2, 766), - Trans(0, 69, 2, 766), - Trans(0, 70, 2, 766), - Trans(0, 72, 2, 766), - Trans(0, 76, 2, 766), - Trans(0, 79, 2, 766), - Trans(0, 80, 2, 766), - Trans(0, 103, 2, 766), - Trans(0, 105, 2, 766), - Trans(0, 108, 2, 766), - Trans(0, 109, 2, 766), + Trans(0, 30, 2, 794), + Trans(0, 36, 1, 793), + Trans(0, 39, 2, 794), + Trans(0, 48, 2, 794), + Trans(0, 49, 2, 794), + Trans(0, 50, 2, 794), + Trans(0, 60, 2, 794), + Trans(0, 64, 2, 794), + Trans(0, 65, 2, 794), + Trans(0, 66, 2, 794), + Trans(0, 70, 2, 794), + Trans(0, 71, 2, 794), + Trans(0, 73, 2, 794), + Trans(0, 77, 2, 794), + Trans(0, 80, 2, 794), + Trans(0, 81, 2, 794), + Trans(0, 104, 2, 794), + Trans(0, 106, 2, 794), + Trans(0, 109, 2, 794), + Trans(0, 110, 2, 794), ], k: 1, }, - /* 397 - "ModuleIfDeclaration" */ + /* 403 - "ModuleIfDeclaration" */ LookaheadDFA { - prod0: 744, + prod0: 772, transitions: &[], k: 0, }, - /* 398 - "ModuleIfDeclarationList" */ + /* 404 - "ModuleIfDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 5, -1), - Trans(0, 35, 6, -1), - Trans(0, 38, 7, -1), - Trans(0, 42, 8, -1), - Trans(0, 47, 9, -1), - Trans(0, 48, 10, -1), - Trans(0, 49, 11, -1), - Trans(0, 57, 1, -1), - Trans(0, 59, 12, -1), - Trans(0, 63, 9, -1), - Trans(0, 64, 13, -1), - Trans(0, 65, 14, -1), - Trans(0, 69, 15, -1), - Trans(0, 70, 16, -1), - Trans(0, 72, 9, -1), - Trans(0, 76, 12, -1), - Trans(0, 79, 12, -1), + Trans(0, 30, 5, -1), + Trans(0, 36, 6, -1), + Trans(0, 39, 7, -1), + Trans(0, 43, 8, -1), + Trans(0, 48, 9, -1), + Trans(0, 49, 10, -1), + Trans(0, 50, 11, -1), + Trans(0, 58, 1, -1), + Trans(0, 60, 12, -1), + Trans(0, 64, 9, -1), + Trans(0, 65, 13, -1), + Trans(0, 66, 14, -1), + Trans(0, 70, 15, -1), + Trans(0, 71, 16, -1), + Trans(0, 73, 9, -1), + Trans(0, 77, 12, -1), Trans(0, 80, 12, -1), - Trans(0, 103, 5, -1), - Trans(0, 105, 17, -1), - Trans(0, 108, 5, -1), - Trans(0, 109, 12, -1), + Trans(0, 81, 12, -1), + Trans(0, 104, 17, -1), + Trans(0, 106, 18, -1), + Trans(0, 109, 17, -1), + Trans(0, 110, 12, -1), Trans(1, 5, 4, -1), - Trans(1, 29, 20, -1), - Trans(1, 38, 35, -1), - Trans(1, 69, 2, -1), - Trans(2, 5, 3, 745), - Trans(2, 6, 3, 745), - Trans(2, 7, 3, 745), - Trans(2, 8, 3, 745), - Trans(2, 9, 3, 745), - Trans(2, 10, 3, 745), - Trans(2, 11, 3, 745), - Trans(2, 18, 3, 745), - Trans(2, 24, 3, 745), - Trans(2, 25, 3, 745), - Trans(2, 26, 3, 745), - Trans(2, 27, 3, 745), - Trans(2, 37, 3, 745), - Trans(2, 38, 3, 745), - Trans(2, 40, 3, 745), - Trans(2, 52, 3, 745), - Trans(2, 69, 3, 745), - Trans(2, 75, 3, 745), - Trans(2, 82, 3, 745), - Trans(2, 85, 3, 745), - Trans(2, 87, 3, 745), - Trans(2, 110, 3, 745), - Trans(2, 111, 3, 745), - Trans(4, 29, 18, 746), - Trans(4, 38, 18, 746), - Trans(4, 69, 3, 745), - Trans(5, 5, 42, -1), - Trans(5, 111, 24, -1), - Trans(6, 5, 38, -1), - Trans(6, 39, 20, -1), - Trans(7, 5, 34, -1), - Trans(7, 29, 20, -1), - Trans(7, 35, 21, -1), - Trans(7, 38, 35, -1), - Trans(7, 42, 35, -1), - Trans(7, 47, 24, -1), + Trans(1, 30, 21, -1), + Trans(1, 39, 37, -1), + Trans(1, 70, 2, -1), + Trans(2, 5, 3, 773), + Trans(2, 6, 3, 773), + Trans(2, 7, 3, 773), + Trans(2, 8, 3, 773), + Trans(2, 9, 3, 773), + Trans(2, 10, 3, 773), + Trans(2, 11, 3, 773), + Trans(2, 18, 3, 773), + Trans(2, 24, 3, 773), + Trans(2, 25, 3, 773), + Trans(2, 26, 3, 773), + Trans(2, 27, 3, 773), + Trans(2, 38, 3, 773), + Trans(2, 39, 3, 773), + Trans(2, 41, 3, 773), + Trans(2, 53, 3, 773), + Trans(2, 70, 3, 773), + Trans(2, 76, 3, 773), + Trans(2, 83, 3, 773), + Trans(2, 86, 3, 773), + Trans(2, 88, 3, 773), + Trans(2, 111, 3, 773), + Trans(2, 112, 3, 773), + Trans(4, 30, 19, 774), + Trans(4, 39, 19, 774), + Trans(4, 70, 3, 773), + Trans(5, 5, 45, -1), + Trans(5, 112, 25, -1), + Trans(6, 5, 40, -1), + Trans(6, 40, 21, -1), + Trans(7, 5, 36, -1), + Trans(7, 30, 21, -1), + Trans(7, 36, 22, -1), + Trans(7, 39, 37, -1), + Trans(7, 43, 37, -1), Trans(7, 48, 25, -1), - Trans(7, 49, 20, -1), - Trans(7, 59, 20, -1), - Trans(7, 63, 24, -1), - Trans(7, 64, 20, -1), - Trans(7, 65, 20, -1), - Trans(7, 69, 27, -1), + Trans(7, 49, 26, -1), + Trans(7, 50, 21, -1), + Trans(7, 60, 21, -1), + Trans(7, 64, 25, -1), + Trans(7, 65, 21, -1), + Trans(7, 66, 21, -1), Trans(7, 70, 28, -1), - Trans(7, 72, 24, -1), - Trans(7, 76, 20, -1), - Trans(7, 79, 20, -1), - Trans(7, 80, 20, -1), - Trans(7, 103, 20, -1), - Trans(7, 105, 20, -1), - Trans(7, 108, 20, -1), - Trans(7, 109, 20, -1), - Trans(8, 0, 18, 746), - Trans(8, 5, 19, -1), - Trans(8, 29, 20, -1), - Trans(8, 35, 21, -1), - Trans(8, 38, 22, -1), - Trans(8, 42, 23, -1), - Trans(8, 47, 24, -1), + Trans(7, 71, 29, -1), + Trans(7, 73, 25, -1), + Trans(7, 77, 21, -1), + Trans(7, 80, 21, -1), + Trans(7, 81, 21, -1), + Trans(7, 104, 21, -1), + Trans(7, 106, 21, -1), + Trans(7, 109, 21, -1), + Trans(7, 110, 21, -1), + Trans(8, 0, 19, 774), + Trans(8, 5, 20, -1), + Trans(8, 30, 21, -1), + Trans(8, 36, 22, -1), + Trans(8, 39, 23, -1), + Trans(8, 43, 24, -1), Trans(8, 48, 25, -1), - Trans(8, 49, 20, -1), - Trans(8, 57, 26, -1), - Trans(8, 58, 25, -1), - Trans(8, 59, 20, -1), - Trans(8, 63, 24, -1), - Trans(8, 64, 20, -1), - Trans(8, 65, 20, -1), - Trans(8, 69, 27, -1), + Trans(8, 49, 26, -1), + Trans(8, 50, 21, -1), + Trans(8, 58, 27, -1), + Trans(8, 59, 26, -1), + Trans(8, 60, 21, -1), + Trans(8, 64, 25, -1), + Trans(8, 65, 21, -1), + Trans(8, 66, 21, -1), Trans(8, 70, 28, -1), - Trans(8, 71, 25, -1), - Trans(8, 72, 24, -1), - Trans(8, 76, 20, -1), - Trans(8, 77, 20, -1), - Trans(8, 79, 20, -1), - Trans(8, 80, 20, -1), - Trans(8, 84, 20, -1), - Trans(8, 88, 20, -1), - Trans(8, 90, 29, -1), - Trans(8, 103, 20, -1), - Trans(8, 105, 20, -1), - Trans(8, 108, 20, -1), - Trans(8, 109, 20, -1), - Trans(9, 5, 36, -1), - Trans(9, 38, 37, -1), - Trans(10, 5, 39, -1), - Trans(10, 40, 20, -1), - Trans(11, 5, 42, -1), - Trans(11, 111, 43, -1), - Trans(12, 5, 42, -1), - Trans(12, 111, 44, -1), - Trans(13, 5, 42, -1), - Trans(13, 111, 45, -1), - Trans(14, 5, 42, -1), - Trans(14, 111, 46, -1), - Trans(15, 5, 30, -1), - Trans(15, 6, 31, -1), - Trans(15, 7, 31, -1), - Trans(15, 8, 31, -1), - Trans(15, 9, 31, -1), - Trans(15, 10, 31, -1), - Trans(15, 11, 31, -1), - Trans(15, 18, 27, -1), - Trans(15, 24, 27, -1), - Trans(15, 25, 27, -1), - Trans(15, 26, 27, -1), - Trans(15, 27, 27, -1), - Trans(15, 37, 32, -1), - Trans(15, 38, 27, -1), - Trans(15, 40, 27, -1), - Trans(15, 52, 27, -1), - Trans(15, 69, 27, -1), - Trans(15, 75, 27, -1), - Trans(15, 82, 31, -1), - Trans(15, 85, 31, -1), - Trans(15, 87, 27, -1), - Trans(15, 110, 33, -1), - Trans(15, 111, 33, -1), - Trans(16, 5, 40, -1), - Trans(16, 110, 41, -1), - Trans(16, 111, 41, -1), - Trans(17, 5, 42, -1), - Trans(17, 111, 47, -1), - Trans(19, 0, 18, 746), - Trans(19, 29, 18, 746), - Trans(19, 35, 18, 746), - Trans(19, 38, 18, 746), - Trans(19, 42, 18, 746), - Trans(19, 47, 18, 746), - Trans(19, 48, 18, 746), - Trans(19, 49, 18, 746), - Trans(19, 57, 18, 746), - Trans(19, 58, 18, 746), - Trans(19, 59, 18, 746), - Trans(19, 63, 18, 746), - Trans(19, 64, 18, 746), - Trans(19, 65, 18, 746), - Trans(19, 69, 18, 746), - Trans(19, 70, 18, 746), - Trans(19, 71, 18, 746), - Trans(19, 72, 18, 746), - Trans(19, 76, 18, 746), - Trans(19, 77, 18, 746), - Trans(19, 79, 18, 746), - Trans(19, 80, 18, 746), - Trans(19, 84, 18, 746), - Trans(19, 88, 18, 746), - Trans(19, 90, 18, 746), - Trans(19, 103, 18, 746), - Trans(19, 105, 18, 746), - Trans(19, 108, 18, 746), - Trans(19, 109, 18, 746), - Trans(20, 5, 18, 746), - Trans(20, 111, 18, 746), - Trans(21, 5, 18, 746), - Trans(21, 39, 18, 746), - Trans(22, 5, 18, 746), - Trans(22, 29, 18, 746), - Trans(22, 35, 18, 746), - Trans(22, 38, 18, 746), - Trans(22, 42, 18, 746), - Trans(22, 47, 18, 746), - Trans(22, 48, 18, 746), - Trans(22, 49, 18, 746), - Trans(22, 58, 18, 746), - Trans(22, 59, 18, 746), - Trans(22, 63, 18, 746), - Trans(22, 64, 18, 746), - Trans(22, 65, 18, 746), - Trans(22, 69, 18, 746), - Trans(22, 70, 18, 746), - Trans(22, 71, 18, 746), - Trans(22, 72, 18, 746), - Trans(22, 76, 18, 746), - Trans(22, 77, 18, 746), - Trans(22, 79, 18, 746), - Trans(22, 80, 18, 746), - Trans(22, 84, 18, 746), - Trans(22, 88, 18, 746), - Trans(22, 90, 18, 746), - Trans(22, 103, 18, 746), - Trans(22, 105, 18, 746), - Trans(22, 108, 18, 746), - Trans(22, 109, 18, 746), - Trans(23, 0, 18, 746), - Trans(23, 5, 18, 746), - Trans(23, 29, 18, 746), - Trans(23, 35, 18, 746), - Trans(23, 38, 18, 746), - Trans(23, 42, 18, 746), - Trans(23, 47, 18, 746), - Trans(23, 48, 18, 746), - Trans(23, 49, 18, 746), - Trans(23, 57, 18, 746), - Trans(23, 58, 18, 746), - Trans(23, 59, 18, 746), - Trans(23, 63, 18, 746), - Trans(23, 64, 18, 746), - Trans(23, 65, 18, 746), - Trans(23, 69, 18, 746), - Trans(23, 70, 18, 746), - Trans(23, 71, 18, 746), - Trans(23, 72, 18, 746), - Trans(23, 76, 18, 746), - Trans(23, 77, 18, 746), - Trans(23, 79, 18, 746), - Trans(23, 80, 18, 746), - Trans(23, 84, 18, 746), - Trans(23, 88, 18, 746), - Trans(23, 90, 18, 746), - Trans(23, 103, 18, 746), - Trans(23, 105, 18, 746), - Trans(23, 108, 18, 746), - Trans(23, 109, 18, 746), - Trans(24, 5, 18, 746), - Trans(24, 38, 18, 746), - Trans(25, 5, 18, 746), - Trans(25, 40, 18, 746), - Trans(26, 5, 18, 746), - Trans(26, 29, 18, 746), - Trans(26, 38, 18, 746), - Trans(26, 69, 18, 746), - Trans(27, 5, 18, 746), - Trans(27, 6, 18, 746), - Trans(27, 7, 18, 746), - Trans(27, 8, 18, 746), - Trans(27, 9, 18, 746), - Trans(27, 10, 18, 746), - Trans(27, 11, 18, 746), - Trans(27, 18, 18, 746), - Trans(27, 24, 18, 746), - Trans(27, 25, 18, 746), - Trans(27, 26, 18, 746), - Trans(27, 27, 18, 746), - Trans(27, 37, 18, 746), - Trans(27, 38, 18, 746), - Trans(27, 40, 18, 746), - Trans(27, 52, 18, 746), - Trans(27, 69, 18, 746), - Trans(27, 75, 18, 746), - Trans(27, 82, 18, 746), - Trans(27, 85, 18, 746), - Trans(27, 87, 18, 746), - Trans(27, 110, 18, 746), - Trans(27, 111, 18, 746), - Trans(28, 5, 18, 746), - Trans(28, 110, 18, 746), - Trans(28, 111, 18, 746), - Trans(29, 5, 18, 746), - Trans(29, 77, 18, 746), - Trans(29, 84, 18, 746), - Trans(29, 88, 18, 746), - Trans(30, 6, 18, 746), - Trans(30, 7, 18, 746), - Trans(30, 8, 18, 746), - Trans(30, 9, 18, 746), - Trans(30, 10, 18, 746), - Trans(30, 11, 18, 746), - Trans(30, 18, 18, 746), - Trans(30, 24, 18, 746), - Trans(30, 25, 18, 746), - Trans(30, 26, 18, 746), - Trans(30, 27, 18, 746), - Trans(30, 37, 18, 746), - Trans(30, 38, 18, 746), - Trans(30, 40, 18, 746), - Trans(30, 52, 18, 746), - Trans(30, 69, 18, 746), - Trans(30, 75, 18, 746), - Trans(30, 82, 18, 746), - Trans(30, 85, 18, 746), - Trans(30, 87, 18, 746), - Trans(30, 110, 18, 746), - Trans(30, 111, 18, 746), - Trans(31, 5, 18, 746), - Trans(31, 16, 18, 746), - Trans(31, 17, 18, 746), - Trans(31, 18, 18, 746), - Trans(31, 19, 18, 746), - Trans(31, 20, 18, 746), - Trans(31, 21, 18, 746), - Trans(31, 22, 18, 746), - Trans(31, 23, 18, 746), - Trans(31, 24, 18, 746), - Trans(31, 25, 18, 746), - Trans(31, 26, 18, 746), - Trans(31, 29, 18, 746), - Trans(31, 46, 18, 746), - Trans(31, 50, 18, 746), - Trans(32, 5, 18, 746), - Trans(32, 6, 18, 746), - Trans(32, 7, 18, 746), - Trans(32, 8, 18, 746), - Trans(32, 9, 18, 746), - Trans(32, 10, 18, 746), - Trans(32, 11, 18, 746), - Trans(32, 18, 18, 746), - Trans(32, 24, 18, 746), - Trans(32, 25, 18, 746), - Trans(32, 26, 18, 746), - Trans(32, 27, 18, 746), - Trans(32, 37, 18, 746), - Trans(32, 38, 18, 746), - Trans(32, 40, 18, 746), - Trans(32, 52, 18, 746), - Trans(32, 56, 18, 746), - Trans(32, 69, 18, 746), - Trans(32, 75, 18, 746), - Trans(32, 82, 18, 746), - Trans(32, 85, 18, 746), - Trans(32, 87, 18, 746), - Trans(32, 110, 18, 746), - Trans(32, 111, 18, 746), - Trans(33, 5, 18, 746), - Trans(33, 16, 18, 746), - Trans(33, 17, 18, 746), - Trans(33, 18, 18, 746), - Trans(33, 19, 18, 746), - Trans(33, 20, 18, 746), - Trans(33, 21, 18, 746), - Trans(33, 22, 18, 746), - Trans(33, 23, 18, 746), - Trans(33, 24, 18, 746), - Trans(33, 25, 18, 746), - Trans(33, 26, 18, 746), - Trans(33, 28, 18, 746), - Trans(33, 29, 18, 746), - Trans(33, 33, 18, 746), - Trans(33, 39, 18, 746), - Trans(33, 40, 18, 746), - Trans(33, 46, 18, 746), - Trans(33, 50, 18, 746), - Trans(34, 29, 18, 746), - Trans(34, 35, 18, 746), - Trans(34, 38, 18, 746), - Trans(34, 42, 18, 746), - Trans(34, 47, 18, 746), - Trans(34, 48, 18, 746), - Trans(34, 49, 18, 746), - Trans(34, 59, 18, 746), - Trans(34, 63, 18, 746), - Trans(34, 64, 18, 746), - Trans(34, 65, 18, 746), - Trans(34, 69, 18, 746), - Trans(34, 70, 18, 746), - Trans(34, 72, 18, 746), - Trans(34, 76, 18, 746), - Trans(34, 79, 18, 746), - Trans(34, 80, 18, 746), - Trans(34, 103, 18, 746), - Trans(34, 105, 18, 746), - Trans(34, 108, 18, 746), - Trans(34, 109, 18, 746), - Trans(35, 5, 18, 746), - Trans(35, 29, 18, 746), - Trans(35, 35, 18, 746), - Trans(35, 38, 18, 746), - Trans(35, 42, 18, 746), - Trans(35, 47, 18, 746), - Trans(35, 48, 18, 746), - Trans(35, 49, 18, 746), - Trans(35, 59, 18, 746), - Trans(35, 63, 18, 746), - Trans(35, 64, 18, 746), - Trans(35, 65, 18, 746), - Trans(35, 69, 18, 746), - Trans(35, 70, 18, 746), - Trans(35, 72, 18, 746), - Trans(35, 76, 18, 746), - Trans(35, 79, 18, 746), - Trans(35, 80, 18, 746), - Trans(35, 103, 18, 746), - Trans(35, 105, 18, 746), - Trans(35, 108, 18, 746), - Trans(35, 109, 18, 746), - Trans(36, 38, 18, 746), - Trans(37, 5, 18, 746), - Trans(37, 42, 18, 746), - Trans(37, 52, 18, 746), - Trans(37, 64, 18, 746), - Trans(37, 68, 18, 746), - Trans(37, 69, 18, 746), - Trans(37, 79, 18, 746), - Trans(37, 98, 18, 746), - Trans(37, 99, 18, 746), - Trans(37, 110, 18, 746), - Trans(37, 111, 18, 746), - Trans(38, 39, 18, 746), - Trans(39, 40, 18, 746), - Trans(40, 110, 18, 746), - Trans(40, 111, 18, 746), - Trans(41, 5, 18, 746), - Trans(41, 28, 18, 746), - Trans(41, 45, 18, 746), - Trans(42, 111, 18, 746), - Trans(43, 5, 18, 746), - Trans(43, 33, 18, 746), - Trans(43, 34, 18, 746), - Trans(43, 39, 18, 746), - Trans(44, 5, 18, 746), - Trans(44, 29, 18, 746), - Trans(45, 5, 18, 746), - Trans(45, 78, 18, 746), - Trans(46, 5, 18, 746), - Trans(46, 13, 18, 746), - Trans(46, 38, 18, 746), - Trans(46, 40, 18, 746), - Trans(47, 5, 18, 746), - Trans(47, 34, 18, 746), + Trans(8, 71, 29, -1), + Trans(8, 72, 26, -1), + Trans(8, 73, 25, -1), + Trans(8, 77, 21, -1), + Trans(8, 78, 21, -1), + Trans(8, 80, 21, -1), + Trans(8, 81, 21, -1), + Trans(8, 85, 21, -1), + Trans(8, 89, 21, -1), + Trans(8, 91, 30, -1), + Trans(8, 104, 21, -1), + Trans(8, 106, 21, -1), + Trans(8, 109, 21, -1), + Trans(8, 110, 21, -1), + Trans(9, 5, 38, -1), + Trans(9, 39, 39, -1), + Trans(10, 5, 41, -1), + Trans(10, 41, 21, -1), + Trans(11, 5, 45, -1), + Trans(11, 112, 46, -1), + Trans(12, 5, 45, -1), + Trans(12, 112, 47, -1), + Trans(13, 5, 45, -1), + Trans(13, 112, 48, -1), + Trans(14, 5, 45, -1), + Trans(14, 112, 49, -1), + Trans(15, 5, 31, -1), + Trans(15, 6, 32, -1), + Trans(15, 7, 32, -1), + Trans(15, 8, 32, -1), + Trans(15, 9, 32, -1), + Trans(15, 10, 32, -1), + Trans(15, 11, 32, -1), + Trans(15, 18, 28, -1), + Trans(15, 24, 28, -1), + Trans(15, 25, 28, -1), + Trans(15, 26, 28, -1), + Trans(15, 27, 28, -1), + Trans(15, 38, 33, -1), + Trans(15, 39, 28, -1), + Trans(15, 41, 28, -1), + Trans(15, 53, 28, -1), + Trans(15, 70, 28, -1), + Trans(15, 76, 28, -1), + Trans(15, 83, 32, -1), + Trans(15, 86, 32, -1), + Trans(15, 88, 28, -1), + Trans(15, 111, 34, -1), + Trans(15, 112, 35, -1), + Trans(16, 5, 42, -1), + Trans(16, 111, 43, -1), + Trans(16, 112, 44, -1), + Trans(17, 5, 45, -1), + Trans(17, 112, 50, -1), + Trans(18, 5, 45, -1), + Trans(18, 112, 51, -1), + Trans(20, 0, 19, 774), + Trans(20, 30, 19, 774), + Trans(20, 36, 19, 774), + Trans(20, 39, 19, 774), + Trans(20, 43, 19, 774), + Trans(20, 48, 19, 774), + Trans(20, 49, 19, 774), + Trans(20, 50, 19, 774), + Trans(20, 58, 19, 774), + Trans(20, 59, 19, 774), + Trans(20, 60, 19, 774), + Trans(20, 64, 19, 774), + Trans(20, 65, 19, 774), + Trans(20, 66, 19, 774), + Trans(20, 70, 19, 774), + Trans(20, 71, 19, 774), + Trans(20, 72, 19, 774), + Trans(20, 73, 19, 774), + Trans(20, 77, 19, 774), + Trans(20, 78, 19, 774), + Trans(20, 80, 19, 774), + Trans(20, 81, 19, 774), + Trans(20, 85, 19, 774), + Trans(20, 89, 19, 774), + Trans(20, 91, 19, 774), + Trans(20, 104, 19, 774), + Trans(20, 106, 19, 774), + Trans(20, 109, 19, 774), + Trans(20, 110, 19, 774), + Trans(21, 5, 19, 774), + Trans(21, 112, 19, 774), + Trans(22, 5, 19, 774), + Trans(22, 40, 19, 774), + Trans(23, 5, 19, 774), + Trans(23, 30, 19, 774), + Trans(23, 36, 19, 774), + Trans(23, 39, 19, 774), + Trans(23, 43, 19, 774), + Trans(23, 48, 19, 774), + Trans(23, 49, 19, 774), + Trans(23, 50, 19, 774), + Trans(23, 59, 19, 774), + Trans(23, 60, 19, 774), + Trans(23, 64, 19, 774), + Trans(23, 65, 19, 774), + Trans(23, 66, 19, 774), + Trans(23, 70, 19, 774), + Trans(23, 71, 19, 774), + Trans(23, 72, 19, 774), + Trans(23, 73, 19, 774), + Trans(23, 77, 19, 774), + Trans(23, 78, 19, 774), + Trans(23, 80, 19, 774), + Trans(23, 81, 19, 774), + Trans(23, 85, 19, 774), + Trans(23, 89, 19, 774), + Trans(23, 91, 19, 774), + Trans(23, 104, 19, 774), + Trans(23, 106, 19, 774), + Trans(23, 109, 19, 774), + Trans(23, 110, 19, 774), + Trans(24, 0, 19, 774), + Trans(24, 5, 19, 774), + Trans(24, 30, 19, 774), + Trans(24, 36, 19, 774), + Trans(24, 39, 19, 774), + Trans(24, 43, 19, 774), + Trans(24, 48, 19, 774), + Trans(24, 49, 19, 774), + Trans(24, 50, 19, 774), + Trans(24, 58, 19, 774), + Trans(24, 59, 19, 774), + Trans(24, 60, 19, 774), + Trans(24, 64, 19, 774), + Trans(24, 65, 19, 774), + Trans(24, 66, 19, 774), + Trans(24, 70, 19, 774), + Trans(24, 71, 19, 774), + Trans(24, 72, 19, 774), + Trans(24, 73, 19, 774), + Trans(24, 77, 19, 774), + Trans(24, 78, 19, 774), + Trans(24, 80, 19, 774), + Trans(24, 81, 19, 774), + Trans(24, 85, 19, 774), + Trans(24, 89, 19, 774), + Trans(24, 91, 19, 774), + Trans(24, 104, 19, 774), + Trans(24, 106, 19, 774), + Trans(24, 109, 19, 774), + Trans(24, 110, 19, 774), + Trans(25, 5, 19, 774), + Trans(25, 39, 19, 774), + Trans(26, 5, 19, 774), + Trans(26, 41, 19, 774), + Trans(27, 5, 19, 774), + Trans(27, 30, 19, 774), + Trans(27, 39, 19, 774), + Trans(27, 70, 19, 774), + Trans(28, 5, 19, 774), + Trans(28, 6, 19, 774), + Trans(28, 7, 19, 774), + Trans(28, 8, 19, 774), + Trans(28, 9, 19, 774), + Trans(28, 10, 19, 774), + Trans(28, 11, 19, 774), + Trans(28, 18, 19, 774), + Trans(28, 24, 19, 774), + Trans(28, 25, 19, 774), + Trans(28, 26, 19, 774), + Trans(28, 27, 19, 774), + Trans(28, 38, 19, 774), + Trans(28, 39, 19, 774), + Trans(28, 41, 19, 774), + Trans(28, 53, 19, 774), + Trans(28, 70, 19, 774), + Trans(28, 76, 19, 774), + Trans(28, 83, 19, 774), + Trans(28, 86, 19, 774), + Trans(28, 88, 19, 774), + Trans(28, 111, 19, 774), + Trans(28, 112, 19, 774), + Trans(29, 5, 19, 774), + Trans(29, 111, 19, 774), + Trans(29, 112, 19, 774), + Trans(30, 5, 19, 774), + Trans(30, 78, 19, 774), + Trans(30, 85, 19, 774), + Trans(30, 89, 19, 774), + Trans(31, 6, 19, 774), + Trans(31, 7, 19, 774), + Trans(31, 8, 19, 774), + Trans(31, 9, 19, 774), + Trans(31, 10, 19, 774), + Trans(31, 11, 19, 774), + Trans(31, 18, 19, 774), + Trans(31, 24, 19, 774), + Trans(31, 25, 19, 774), + Trans(31, 26, 19, 774), + Trans(31, 27, 19, 774), + Trans(31, 38, 19, 774), + Trans(31, 39, 19, 774), + Trans(31, 41, 19, 774), + Trans(31, 53, 19, 774), + Trans(31, 70, 19, 774), + Trans(31, 76, 19, 774), + Trans(31, 83, 19, 774), + Trans(31, 86, 19, 774), + Trans(31, 88, 19, 774), + Trans(31, 111, 19, 774), + Trans(31, 112, 19, 774), + Trans(32, 5, 19, 774), + Trans(32, 16, 19, 774), + Trans(32, 17, 19, 774), + Trans(32, 18, 19, 774), + Trans(32, 19, 19, 774), + Trans(32, 20, 19, 774), + Trans(32, 21, 19, 774), + Trans(32, 22, 19, 774), + Trans(32, 23, 19, 774), + Trans(32, 24, 19, 774), + Trans(32, 25, 19, 774), + Trans(32, 26, 19, 774), + Trans(32, 30, 19, 774), + Trans(32, 47, 19, 774), + Trans(32, 51, 19, 774), + Trans(33, 5, 19, 774), + Trans(33, 6, 19, 774), + Trans(33, 7, 19, 774), + Trans(33, 8, 19, 774), + Trans(33, 9, 19, 774), + Trans(33, 10, 19, 774), + Trans(33, 11, 19, 774), + Trans(33, 18, 19, 774), + Trans(33, 24, 19, 774), + Trans(33, 25, 19, 774), + Trans(33, 26, 19, 774), + Trans(33, 27, 19, 774), + Trans(33, 38, 19, 774), + Trans(33, 39, 19, 774), + Trans(33, 41, 19, 774), + Trans(33, 53, 19, 774), + Trans(33, 57, 19, 774), + Trans(33, 70, 19, 774), + Trans(33, 76, 19, 774), + Trans(33, 83, 19, 774), + Trans(33, 86, 19, 774), + Trans(33, 88, 19, 774), + Trans(33, 111, 19, 774), + Trans(33, 112, 19, 774), + Trans(34, 5, 19, 774), + Trans(34, 16, 19, 774), + Trans(34, 17, 19, 774), + Trans(34, 18, 19, 774), + Trans(34, 19, 19, 774), + Trans(34, 20, 19, 774), + Trans(34, 21, 19, 774), + Trans(34, 22, 19, 774), + Trans(34, 23, 19, 774), + Trans(34, 24, 19, 774), + Trans(34, 25, 19, 774), + Trans(34, 26, 19, 774), + Trans(34, 29, 19, 774), + Trans(34, 30, 19, 774), + Trans(34, 34, 19, 774), + Trans(34, 40, 19, 774), + Trans(34, 41, 19, 774), + Trans(34, 47, 19, 774), + Trans(34, 51, 19, 774), + Trans(35, 5, 19, 774), + Trans(35, 16, 19, 774), + Trans(35, 17, 19, 774), + Trans(35, 18, 19, 774), + Trans(35, 19, 19, 774), + Trans(35, 20, 19, 774), + Trans(35, 21, 19, 774), + Trans(35, 22, 19, 774), + Trans(35, 23, 19, 774), + Trans(35, 24, 19, 774), + Trans(35, 25, 19, 774), + Trans(35, 26, 19, 774), + Trans(35, 28, 19, 774), + Trans(35, 29, 19, 774), + Trans(35, 30, 19, 774), + Trans(35, 34, 19, 774), + Trans(35, 40, 19, 774), + Trans(35, 41, 19, 774), + Trans(35, 47, 19, 774), + Trans(35, 51, 19, 774), + Trans(36, 30, 19, 774), + Trans(36, 36, 19, 774), + Trans(36, 39, 19, 774), + Trans(36, 43, 19, 774), + Trans(36, 48, 19, 774), + Trans(36, 49, 19, 774), + Trans(36, 50, 19, 774), + Trans(36, 60, 19, 774), + Trans(36, 64, 19, 774), + Trans(36, 65, 19, 774), + Trans(36, 66, 19, 774), + Trans(36, 70, 19, 774), + Trans(36, 71, 19, 774), + Trans(36, 73, 19, 774), + Trans(36, 77, 19, 774), + Trans(36, 80, 19, 774), + Trans(36, 81, 19, 774), + Trans(36, 104, 19, 774), + Trans(36, 106, 19, 774), + Trans(36, 109, 19, 774), + Trans(36, 110, 19, 774), + Trans(37, 5, 19, 774), + Trans(37, 30, 19, 774), + Trans(37, 36, 19, 774), + Trans(37, 39, 19, 774), + Trans(37, 43, 19, 774), + Trans(37, 48, 19, 774), + Trans(37, 49, 19, 774), + Trans(37, 50, 19, 774), + Trans(37, 60, 19, 774), + Trans(37, 64, 19, 774), + Trans(37, 65, 19, 774), + Trans(37, 66, 19, 774), + Trans(37, 70, 19, 774), + Trans(37, 71, 19, 774), + Trans(37, 73, 19, 774), + Trans(37, 77, 19, 774), + Trans(37, 80, 19, 774), + Trans(37, 81, 19, 774), + Trans(37, 104, 19, 774), + Trans(37, 106, 19, 774), + Trans(37, 109, 19, 774), + Trans(37, 110, 19, 774), + Trans(38, 39, 19, 774), + Trans(39, 5, 19, 774), + Trans(39, 43, 19, 774), + Trans(39, 53, 19, 774), + Trans(39, 65, 19, 774), + Trans(39, 69, 19, 774), + Trans(39, 70, 19, 774), + Trans(39, 80, 19, 774), + Trans(39, 99, 19, 774), + Trans(39, 100, 19, 774), + Trans(39, 111, 19, 774), + Trans(39, 112, 19, 774), + Trans(40, 40, 19, 774), + Trans(41, 41, 19, 774), + Trans(42, 111, 19, 774), + Trans(42, 112, 19, 774), + Trans(43, 5, 19, 774), + Trans(43, 29, 19, 774), + Trans(43, 46, 19, 774), + Trans(44, 5, 19, 774), + Trans(44, 28, 19, 774), + Trans(44, 29, 19, 774), + Trans(44, 46, 19, 774), + Trans(45, 112, 19, 774), + Trans(46, 5, 19, 774), + Trans(46, 34, 19, 774), + Trans(46, 35, 19, 774), + Trans(46, 40, 19, 774), + Trans(47, 5, 19, 774), + Trans(47, 30, 19, 774), + Trans(48, 5, 19, 774), + Trans(48, 79, 19, 774), + Trans(49, 5, 19, 774), + Trans(49, 13, 19, 774), + Trans(49, 28, 19, 774), + Trans(49, 39, 19, 774), + Trans(49, 41, 19, 774), + Trans(50, 5, 19, 774), + Trans(50, 28, 19, 774), + Trans(50, 39, 19, 774), + Trans(51, 5, 19, 774), + Trans(51, 35, 19, 774), ], k: 3, }, - /* 399 - "ModuleIfDeclarationOpt" */ + /* 405 - "ModuleIfDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 2, 748), - Trans(0, 35, 2, 748), - Trans(0, 38, 2, 748), - Trans(0, 42, 2, 748), - Trans(0, 47, 2, 748), - Trans(0, 48, 2, 748), - Trans(0, 49, 2, 748), - Trans(0, 57, 1, 747), - Trans(0, 59, 2, 748), - Trans(0, 63, 2, 748), - Trans(0, 64, 2, 748), - Trans(0, 65, 2, 748), - Trans(0, 69, 2, 748), - Trans(0, 70, 2, 748), - Trans(0, 72, 2, 748), - Trans(0, 76, 2, 748), - Trans(0, 79, 2, 748), - Trans(0, 80, 2, 748), - Trans(0, 103, 2, 748), - Trans(0, 105, 2, 748), - Trans(0, 108, 2, 748), - Trans(0, 109, 2, 748), + Trans(0, 30, 2, 776), + Trans(0, 36, 2, 776), + Trans(0, 39, 2, 776), + Trans(0, 43, 2, 776), + Trans(0, 48, 2, 776), + Trans(0, 49, 2, 776), + Trans(0, 50, 2, 776), + Trans(0, 58, 1, 775), + Trans(0, 60, 2, 776), + Trans(0, 64, 2, 776), + Trans(0, 65, 2, 776), + Trans(0, 66, 2, 776), + Trans(0, 70, 2, 776), + Trans(0, 71, 2, 776), + Trans(0, 73, 2, 776), + Trans(0, 77, 2, 776), + Trans(0, 80, 2, 776), + Trans(0, 81, 2, 776), + Trans(0, 104, 2, 776), + Trans(0, 106, 2, 776), + Trans(0, 109, 2, 776), + Trans(0, 110, 2, 776), ], k: 1, }, - /* 400 - "ModuleItem" */ + /* 406 - "ModuleItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 14, 780), - Trans(0, 47, 7, 773), - Trans(0, 48, 6, 772), - Trans(0, 49, 8, 774), - Trans(0, 59, 12, 778), - Trans(0, 63, 17, 783), - Trans(0, 64, 11, 777), - Trans(0, 65, 9, 775), - Trans(0, 69, 10, 776), - Trans(0, 70, 15, 781), - Trans(0, 72, 16, 782), - Trans(0, 76, 3, 769), - Trans(0, 79, 1, 767), - Trans(0, 80, 5, 771), - Trans(0, 103, 13, 779), - Trans(0, 105, 4, 770), - Trans(0, 108, 13, 779), - Trans(0, 109, 2, 768), + Trans(0, 30, 14, 808), + Trans(0, 48, 7, 801), + Trans(0, 49, 6, 800), + Trans(0, 50, 8, 802), + Trans(0, 60, 12, 806), + Trans(0, 64, 17, 811), + Trans(0, 65, 11, 805), + Trans(0, 66, 9, 803), + Trans(0, 70, 10, 804), + Trans(0, 71, 15, 809), + Trans(0, 73, 16, 810), + Trans(0, 77, 3, 797), + Trans(0, 80, 1, 795), + Trans(0, 81, 5, 799), + Trans(0, 104, 13, 807), + Trans(0, 106, 4, 798), + Trans(0, 109, 13, 807), + Trans(0, 110, 2, 796), ], k: 1, }, - /* 401 - "ModuleNamedBlock" */ + /* 407 - "ModuleNamedBlock" */ LookaheadDFA { - prod0: 752, + prod0: 780, transitions: &[], k: 0, }, - /* 402 - "ModuleNamedBlockList" */ + /* 408 - "ModuleNamedBlockList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 753), - Trans(0, 35, 1, 753), - Trans(0, 38, 1, 753), - Trans(0, 42, 2, 754), - Trans(0, 47, 1, 753), - Trans(0, 48, 1, 753), - Trans(0, 49, 1, 753), - Trans(0, 59, 1, 753), - Trans(0, 63, 1, 753), - Trans(0, 64, 1, 753), - Trans(0, 65, 1, 753), - Trans(0, 69, 1, 753), - Trans(0, 70, 1, 753), - Trans(0, 72, 1, 753), - Trans(0, 76, 1, 753), - Trans(0, 79, 1, 753), - Trans(0, 80, 1, 753), - Trans(0, 103, 1, 753), - Trans(0, 105, 1, 753), - Trans(0, 108, 1, 753), - Trans(0, 109, 1, 753), + Trans(0, 30, 1, 781), + Trans(0, 36, 1, 781), + Trans(0, 39, 1, 781), + Trans(0, 43, 2, 782), + Trans(0, 48, 1, 781), + Trans(0, 49, 1, 781), + Trans(0, 50, 1, 781), + Trans(0, 60, 1, 781), + Trans(0, 64, 1, 781), + Trans(0, 65, 1, 781), + Trans(0, 66, 1, 781), + Trans(0, 70, 1, 781), + Trans(0, 71, 1, 781), + Trans(0, 73, 1, 781), + Trans(0, 77, 1, 781), + Trans(0, 80, 1, 781), + Trans(0, 81, 1, 781), + Trans(0, 104, 1, 781), + Trans(0, 106, 1, 781), + Trans(0, 109, 1, 781), + Trans(0, 110, 1, 781), ], k: 1, }, - /* 403 - "ModuleOptionalNamedBlock" */ + /* 409 - "ModuleOptionalNamedBlock" */ LookaheadDFA { - prod0: 755, + prod0: 783, transitions: &[], k: 0, }, - /* 404 - "ModuleOptionalNamedBlockList" */ + /* 410 - "ModuleOptionalNamedBlockList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 1, 756), - Trans(0, 35, 1, 756), - Trans(0, 38, 1, 756), - Trans(0, 42, 2, 757), - Trans(0, 47, 1, 756), - Trans(0, 48, 1, 756), - Trans(0, 49, 1, 756), - Trans(0, 59, 1, 756), - Trans(0, 63, 1, 756), - Trans(0, 64, 1, 756), - Trans(0, 65, 1, 756), - Trans(0, 69, 1, 756), - Trans(0, 70, 1, 756), - Trans(0, 72, 1, 756), - Trans(0, 76, 1, 756), - Trans(0, 79, 1, 756), - Trans(0, 80, 1, 756), - Trans(0, 103, 1, 756), - Trans(0, 105, 1, 756), - Trans(0, 108, 1, 756), - Trans(0, 109, 1, 756), + Trans(0, 30, 1, 784), + Trans(0, 36, 1, 784), + Trans(0, 39, 1, 784), + Trans(0, 43, 2, 785), + Trans(0, 48, 1, 784), + Trans(0, 49, 1, 784), + Trans(0, 50, 1, 784), + Trans(0, 60, 1, 784), + Trans(0, 64, 1, 784), + Trans(0, 65, 1, 784), + Trans(0, 66, 1, 784), + Trans(0, 70, 1, 784), + Trans(0, 71, 1, 784), + Trans(0, 73, 1, 784), + Trans(0, 77, 1, 784), + Trans(0, 80, 1, 784), + Trans(0, 81, 1, 784), + Trans(0, 104, 1, 784), + Trans(0, 106, 1, 784), + Trans(0, 109, 1, 784), + Trans(0, 110, 1, 784), ], k: 1, }, - /* 405 - "ModuleOptionalNamedBlockOpt" */ + /* 411 - "ModuleOptionalNamedBlockOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 29, 1, 758), Trans(0, 38, 2, 759)], + transitions: &[Trans(0, 30, 1, 786), Trans(0, 39, 2, 787)], k: 1, }, - /* 406 - "ModuleTerm" */ + /* 412 - "ModuleTerm" */ LookaheadDFA { - prod0: 79, + prod0: 80, transitions: &[], k: 0, }, - /* 407 - "ModuleToken" */ + /* 413 - "ModuleToken" */ LookaheadDFA { - prod0: 190, + prod0: 192, transitions: &[], k: 0, }, - /* 408 - "Msb" */ + /* 414 - "Msb" */ LookaheadDFA { - prod0: 299, + prod0: 302, transitions: &[], k: 0, }, - /* 409 - "MsbTerm" */ + /* 415 - "MsbTerm" */ LookaheadDFA { - prod0: 80, + prod0: 81, transitions: &[], k: 0, }, - /* 410 - "MsbToken" */ + /* 416 - "MsbToken" */ LookaheadDFA { - prod0: 191, + prod0: 193, transitions: &[], k: 0, }, - /* 411 - "Number" */ + /* 417 - "Number" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 7, 2, 326), - Trans(0, 8, 2, 326), - Trans(0, 9, 1, 325), - Trans(0, 10, 1, 325), - Trans(0, 11, 1, 325), + Trans(0, 7, 2, 329), + Trans(0, 8, 2, 329), + Trans(0, 9, 1, 328), + Trans(0, 10, 1, 328), + Trans(0, 11, 1, 328), ], k: 1, }, - /* 412 - "Operator01" */ + /* 418 - "Operator01" */ LookaheadDFA { - prod0: 226, + prod0: 228, transitions: &[], k: 0, }, - /* 413 - "Operator01Term" */ + /* 419 - "Operator01Term" */ LookaheadDFA { prod0: 18, transitions: &[], k: 0, }, - /* 414 - "Operator01Token" */ + /* 420 - "Operator01Token" */ LookaheadDFA { - prod0: 119, + prod0: 120, transitions: &[], k: 0, }, - /* 415 - "Operator02" */ + /* 421 - "Operator02" */ LookaheadDFA { - prod0: 227, + prod0: 229, transitions: &[], k: 0, }, - /* 416 - "Operator02Term" */ + /* 422 - "Operator02Term" */ LookaheadDFA { prod0: 17, transitions: &[], k: 0, }, - /* 417 - "Operator02Token" */ + /* 423 - "Operator02Token" */ LookaheadDFA { - prod0: 120, + prod0: 121, transitions: &[], k: 0, }, - /* 418 - "Operator03" */ + /* 424 - "Operator03" */ LookaheadDFA { - prod0: 228, + prod0: 230, transitions: &[], k: 0, }, - /* 419 - "Operator03Term" */ + /* 425 - "Operator03Term" */ LookaheadDFA { prod0: 21, transitions: &[], k: 0, }, - /* 420 - "Operator03Token" */ + /* 426 - "Operator03Token" */ LookaheadDFA { - prod0: 121, + prod0: 122, transitions: &[], k: 0, }, - /* 421 - "Operator04" */ + /* 427 - "Operator04" */ LookaheadDFA { - prod0: 229, + prod0: 231, transitions: &[], k: 0, }, - /* 422 - "Operator04Term" */ + /* 428 - "Operator04Term" */ LookaheadDFA { prod0: 20, transitions: &[], k: 0, }, - /* 423 - "Operator04Token" */ + /* 429 - "Operator04Token" */ LookaheadDFA { - prod0: 122, + prod0: 123, transitions: &[], k: 0, }, - /* 424 - "Operator05" */ + /* 430 - "Operator05" */ LookaheadDFA { - prod0: 230, + prod0: 232, transitions: &[], k: 0, }, - /* 425 - "Operator05Term" */ + /* 431 - "Operator05Term" */ LookaheadDFA { prod0: 19, transitions: &[], k: 0, }, - /* 426 - "Operator05Token" */ + /* 432 - "Operator05Token" */ LookaheadDFA { - prod0: 123, + prod0: 124, transitions: &[], k: 0, }, - /* 427 - "Operator06" */ + /* 433 - "Operator06" */ LookaheadDFA { - prod0: 231, + prod0: 233, transitions: &[], k: 0, }, - /* 428 - "Operator06Term" */ + /* 434 - "Operator06Term" */ LookaheadDFA { prod0: 16, transitions: &[], k: 0, }, - /* 429 - "Operator06Token" */ + /* 435 - "Operator06Token" */ LookaheadDFA { - prod0: 124, + prod0: 125, transitions: &[], k: 0, }, - /* 430 - "Operator07" */ + /* 436 - "Operator07" */ LookaheadDFA { - prod0: 232, + prod0: 234, transitions: &[], k: 0, }, - /* 431 - "Operator07Term" */ + /* 437 - "Operator07Term" */ LookaheadDFA { prod0: 15, transitions: &[], k: 0, }, - /* 432 - "Operator07Token" */ + /* 438 - "Operator07Token" */ LookaheadDFA { - prod0: 125, + prod0: 126, transitions: &[], k: 0, }, - /* 433 - "Operator08" */ + /* 439 - "Operator08" */ LookaheadDFA { - prod0: 233, + prod0: 235, transitions: &[], k: 0, }, - /* 434 - "Operator08Term" */ + /* 440 - "Operator08Term" */ LookaheadDFA { prod0: 14, transitions: &[], k: 0, }, - /* 435 - "Operator08Token" */ + /* 441 - "Operator08Token" */ LookaheadDFA { - prod0: 126, + prod0: 127, transitions: &[], k: 0, }, - /* 436 - "Operator09" */ + /* 442 - "Operator09" */ LookaheadDFA { - prod0: 234, + prod0: 236, transitions: &[], k: 0, }, - /* 437 - "Operator09Term" */ + /* 443 - "Operator09Term" */ LookaheadDFA { prod0: 13, transitions: &[], k: 0, }, - /* 438 - "Operator09Token" */ + /* 444 - "Operator09Token" */ LookaheadDFA { - prod0: 127, + prod0: 128, transitions: &[], k: 0, }, - /* 439 - "Operator10" */ + /* 445 - "Operator10" */ LookaheadDFA { - prod0: 235, + prod0: 237, transitions: &[], k: 0, }, - /* 440 - "Operator10Term" */ + /* 446 - "Operator10Term" */ LookaheadDFA { prod0: 12, transitions: &[], k: 0, }, - /* 441 - "Operator10Token" */ + /* 447 - "Operator10Token" */ LookaheadDFA { - prod0: 128, + prod0: 129, transitions: &[], k: 0, }, - /* 442 - "Operator11" */ + /* 448 - "Operator11" */ LookaheadDFA { - prod0: 236, + prod0: 238, transitions: &[], k: 0, }, - /* 443 - "Operator11Term" */ + /* 449 - "Operator11Term" */ LookaheadDFA { prod0: 11, transitions: &[], k: 0, }, - /* 444 - "Operator11Token" */ + /* 450 - "Operator11Token" */ LookaheadDFA { - prod0: 129, + prod0: 130, transitions: &[], k: 0, }, - /* 445 - "Output" */ + /* 451 - "Output" */ LookaheadDFA { - prod0: 300, + prod0: 303, transitions: &[], k: 0, }, - /* 446 - "OutputTerm" */ + /* 452 - "OutputTerm" */ LookaheadDFA { - prod0: 81, + prod0: 82, transitions: &[], k: 0, }, - /* 447 - "OutputToken" */ + /* 453 - "OutputToken" */ LookaheadDFA { - prod0: 192, + prod0: 194, transitions: &[], k: 0, }, - /* 448 - "Outside" */ + /* 454 - "Outside" */ LookaheadDFA { - prod0: 301, + prod0: 304, transitions: &[], k: 0, }, - /* 449 - "OutsideExpression" */ + /* 455 - "OutsideExpression" */ LookaheadDFA { - prod0: 454, + prod0: 461, transitions: &[], k: 0, }, - /* 450 - "OutsideTerm" */ + /* 456 - "OutsideTerm" */ LookaheadDFA { - prod0: 82, + prod0: 83, transitions: &[], k: 0, }, - /* 451 - "OutsideToken" */ + /* 457 - "OutsideToken" */ LookaheadDFA { - prod0: 193, + prod0: 195, transitions: &[], k: 0, }, - /* 452 - "Package" */ + /* 458 - "Package" */ LookaheadDFA { - prod0: 302, + prod0: 305, transitions: &[], k: 0, }, - /* 453 - "PackageDeclaration" */ + /* 459 - "PackageDeclaration" */ LookaheadDFA { - prod0: 828, + prod0: 858, transitions: &[], k: 0, }, - /* 454 - "PackageDeclarationList" */ + /* 460 - "PackageDeclarationList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 829), - Trans(0, 38, 1, 829), - Trans(0, 42, 2, 830), - Trans(0, 59, 1, 829), - Trans(0, 60, 1, 829), - Trans(0, 63, 1, 829), - Trans(0, 65, 1, 829), - Trans(0, 70, 1, 829), - Trans(0, 72, 1, 829), - Trans(0, 80, 1, 829), - Trans(0, 103, 1, 829), - Trans(0, 105, 1, 829), - Trans(0, 108, 1, 829), - Trans(0, 109, 1, 829), + Trans(0, 36, 1, 859), + Trans(0, 39, 1, 859), + Trans(0, 43, 2, 860), + Trans(0, 60, 1, 859), + Trans(0, 61, 1, 859), + Trans(0, 64, 1, 859), + Trans(0, 66, 1, 859), + Trans(0, 71, 1, 859), + Trans(0, 73, 1, 859), + Trans(0, 81, 1, 859), + Trans(0, 104, 1, 859), + Trans(0, 106, 1, 859), + Trans(0, 109, 1, 859), + Trans(0, 110, 1, 859), ], k: 1, }, - /* 455 - "PackageDeclarationOpt" */ + /* 461 - "PackageDeclarationOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 89, 2, 864), Trans(0, 91, 1, 863)], + k: 1, + }, + /* 462 - "PackageDeclarationOpt0" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 88, 2, 832), Trans(0, 90, 1, 831)], + transitions: &[Trans(0, 28, 1, 861), Trans(0, 39, 2, 862)], k: 1, }, - /* 456 - "PackageGroup" */ + /* 463 - "PackageGroup" */ LookaheadDFA { - prod0: 833, + prod0: 865, transitions: &[], k: 0, }, - /* 457 - "PackageGroupGroup" */ + /* 464 - "PackageGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 38, 1, 834), - Trans(0, 59, 2, 837), - Trans(0, 60, 2, 837), - Trans(0, 63, 2, 837), - Trans(0, 65, 2, 837), - Trans(0, 70, 2, 837), - Trans(0, 72, 2, 837), - Trans(0, 80, 2, 837), - Trans(0, 103, 2, 837), - Trans(0, 105, 2, 837), - Trans(0, 108, 2, 837), - Trans(0, 109, 2, 837), + Trans(0, 39, 1, 866), + Trans(0, 60, 2, 869), + Trans(0, 61, 2, 869), + Trans(0, 64, 2, 869), + Trans(0, 66, 2, 869), + Trans(0, 71, 2, 869), + Trans(0, 73, 2, 869), + Trans(0, 81, 2, 869), + Trans(0, 104, 2, 869), + Trans(0, 106, 2, 869), + Trans(0, 109, 2, 869), + Trans(0, 110, 2, 869), ], k: 1, }, - /* 458 - "PackageGroupGroupList" */ + /* 465 - "PackageGroupGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 835), - Trans(0, 38, 1, 835), - Trans(0, 42, 2, 836), - Trans(0, 59, 1, 835), - Trans(0, 60, 1, 835), - Trans(0, 63, 1, 835), - Trans(0, 65, 1, 835), - Trans(0, 70, 1, 835), - Trans(0, 72, 1, 835), - Trans(0, 80, 1, 835), - Trans(0, 103, 1, 835), - Trans(0, 105, 1, 835), - Trans(0, 108, 1, 835), - Trans(0, 109, 1, 835), + Trans(0, 36, 1, 867), + Trans(0, 39, 1, 867), + Trans(0, 43, 2, 868), + Trans(0, 60, 1, 867), + Trans(0, 61, 1, 867), + Trans(0, 64, 1, 867), + Trans(0, 66, 1, 867), + Trans(0, 71, 1, 867), + Trans(0, 73, 1, 867), + Trans(0, 81, 1, 867), + Trans(0, 104, 1, 867), + Trans(0, 106, 1, 867), + Trans(0, 109, 1, 867), + Trans(0, 110, 1, 867), ], k: 1, }, - /* 459 - "PackageGroupList" */ + /* 466 - "PackageGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 838), - Trans(0, 38, 2, 839), - Trans(0, 59, 2, 839), - Trans(0, 60, 2, 839), - Trans(0, 63, 2, 839), - Trans(0, 65, 2, 839), - Trans(0, 70, 2, 839), - Trans(0, 72, 2, 839), - Trans(0, 80, 2, 839), - Trans(0, 103, 2, 839), - Trans(0, 105, 2, 839), - Trans(0, 108, 2, 839), - Trans(0, 109, 2, 839), + Trans(0, 36, 1, 870), + Trans(0, 39, 2, 871), + Trans(0, 60, 2, 871), + Trans(0, 61, 2, 871), + Trans(0, 64, 2, 871), + Trans(0, 66, 2, 871), + Trans(0, 71, 2, 871), + Trans(0, 73, 2, 871), + Trans(0, 81, 2, 871), + Trans(0, 104, 2, 871), + Trans(0, 106, 2, 871), + Trans(0, 109, 2, 871), + Trans(0, 110, 2, 871), ], k: 1, }, - /* 460 - "PackageItem" */ + /* 467 - "PackageItem" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 59, 4, 843), - Trans(0, 60, 8, 847), - Trans(0, 63, 10, 849), - Trans(0, 65, 6, 845), - Trans(0, 70, 7, 846), - Trans(0, 72, 9, 848), - Trans(0, 80, 2, 841), - Trans(0, 103, 5, 844), - Trans(0, 105, 3, 842), - Trans(0, 108, 5, 844), - Trans(0, 109, 1, 840), + Trans(0, 60, 4, 875), + Trans(0, 61, 8, 879), + Trans(0, 64, 10, 881), + Trans(0, 66, 6, 877), + Trans(0, 71, 7, 878), + Trans(0, 73, 9, 880), + Trans(0, 81, 2, 873), + Trans(0, 104, 5, 876), + Trans(0, 106, 3, 874), + Trans(0, 109, 5, 876), + Trans(0, 110, 1, 872), ], k: 1, }, - /* 461 - "PackageTerm" */ + /* 468 - "PackageTerm" */ LookaheadDFA { - prod0: 83, + prod0: 84, transitions: &[], k: 0, }, - /* 462 - "PackageToken" */ + /* 469 - "PackageToken" */ LookaheadDFA { - prod0: 194, + prod0: 196, transitions: &[], k: 0, }, - /* 463 - "Param" */ + /* 470 - "Param" */ LookaheadDFA { - prod0: 303, + prod0: 306, transitions: &[], k: 0, }, - /* 464 - "ParamTerm" */ + /* 471 - "ParamTerm" */ LookaheadDFA { - prod0: 84, + prod0: 85, transitions: &[], k: 0, }, - /* 465 - "ParamToken" */ + /* 472 - "ParamToken" */ LookaheadDFA { - prod0: 195, + prod0: 197, transitions: &[], k: 0, }, - /* 466 - "PlusColon" */ + /* 473 - "PlusColon" */ LookaheadDFA { - prod0: 253, + prod0: 256, transitions: &[], k: 0, }, - /* 467 - "PlusColonTerm" */ + /* 474 - "PlusColonTerm" */ LookaheadDFA { prod0: 9, transitions: &[], k: 0, }, - /* 468 - "PlusColonToken" */ + /* 475 - "PlusColonToken" */ LookaheadDFA { - prod0: 146, + prod0: 148, transitions: &[], k: 0, }, - /* 469 - "PortDeclaration" */ + /* 476 - "PortDeclaration" */ LookaheadDFA { - prod0: 695, + prod0: 719, transitions: &[], k: 0, }, - /* 470 - "PortDeclarationGroup" */ + /* 477 - "PortDeclarationGroup" */ LookaheadDFA { - prod0: 703, + prod0: 727, transitions: &[], k: 0, }, - /* 471 - "PortDeclarationGroupGroup" */ + /* 478 - "PortDeclarationGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 38, 1, 704), Trans(0, 111, 2, 705)], + transitions: &[Trans(0, 39, 1, 728), Trans(0, 112, 2, 729)], k: 1, }, - /* 472 - "PortDeclarationGroupList" */ + /* 479 - "PortDeclarationGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 706), - Trans(0, 38, 2, 707), - Trans(0, 111, 2, 707), + Trans(0, 36, 1, 730), + Trans(0, 39, 2, 731), + Trans(0, 112, 2, 731), ], k: 1, }, - /* 473 - "PortDeclarationItem" */ + /* 480 - "PortDeclarationItem" */ LookaheadDFA { - prod0: 708, + prod0: 732, transitions: &[], k: 0, }, - /* 474 - "PortDeclarationItemGroup" */ + /* 481 - "PortDeclarationItemGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 73, 1, 709), - Trans(0, 74, 1, 709), - Trans(0, 77, 2, 710), - Trans(0, 83, 1, 709), - Trans(0, 86, 1, 709), - Trans(0, 91, 1, 709), + Trans(0, 74, 1, 733), + Trans(0, 75, 1, 733), + Trans(0, 78, 2, 734), + Trans(0, 84, 1, 733), + Trans(0, 87, 1, 733), + Trans(0, 92, 1, 733), ], k: 1, }, - /* 475 - "PortDeclarationItemOpt" */ + /* 482 - "PortDeclarationItemOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 2, 712), - Trans(0, 39, 1, 711), - Trans(0, 42, 2, 712), - Trans(0, 44, 2, 712), + Trans(0, 31, 2, 736), + Trans(0, 40, 1, 735), + Trans(0, 43, 2, 736), + Trans(0, 45, 2, 736), ], k: 1, }, - /* 476 - "PortDeclarationList" */ + /* 483 - "PortDeclarationList" */ LookaheadDFA { - prod0: 698, + prod0: 722, transitions: &[], k: 0, }, - /* 477 - "PortDeclarationListList" */ + /* 484 - "PortDeclarationListList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 7, -1), - Trans(0, 44, 8, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 7, -1), + Trans(0, 45, 8, -1), Trans(1, 5, 6, -1), - Trans(1, 35, 2, -1), - Trans(1, 38, 4, -1), - Trans(1, 42, 15, -1), - Trans(1, 44, 16, -1), - Trans(1, 111, 5, -1), - Trans(2, 5, 3, 699), - Trans(2, 39, 3, 699), - Trans(4, 5, 3, 699), - Trans(4, 35, 3, 699), - Trans(4, 38, 3, 699), - Trans(4, 111, 3, 699), - Trans(5, 5, 3, 699), - Trans(5, 29, 3, 699), - Trans(6, 35, 3, 699), - Trans(6, 38, 3, 699), - Trans(6, 42, 12, 700), - Trans(6, 44, 12, 700), - Trans(6, 111, 3, 699), + Trans(1, 36, 2, -1), + Trans(1, 39, 4, -1), + Trans(1, 43, 15, -1), + Trans(1, 45, 16, -1), + Trans(1, 112, 5, -1), + Trans(2, 5, 3, 723), + Trans(2, 40, 3, 723), + Trans(4, 5, 3, 723), + Trans(4, 36, 3, 723), + Trans(4, 39, 3, 723), + Trans(4, 112, 3, 723), + Trans(5, 5, 3, 723), + Trans(5, 30, 3, 723), + Trans(6, 36, 3, 723), + Trans(6, 39, 3, 723), + Trans(6, 43, 12, 724), + Trans(6, 45, 12, 724), + Trans(6, 112, 3, 723), Trans(7, 5, 13, -1), - Trans(7, 30, 14, -1), - Trans(7, 42, 15, -1), - Trans(7, 44, 16, -1), + Trans(7, 31, 14, -1), + Trans(7, 43, 15, -1), + Trans(7, 45, 16, -1), Trans(8, 5, 9, -1), Trans(8, 13, 10, -1), - Trans(8, 38, 11, -1), - Trans(9, 13, 12, 700), - Trans(9, 38, 12, 700), - Trans(10, 5, 12, 700), - Trans(10, 51, 12, 700), - Trans(10, 53, 12, 700), - Trans(10, 54, 12, 700), - Trans(10, 55, 12, 700), - Trans(10, 61, 12, 700), - Trans(10, 62, 12, 700), - Trans(10, 66, 12, 700), - Trans(10, 67, 12, 700), - Trans(10, 81, 12, 700), - Trans(10, 93, 12, 700), - Trans(10, 94, 12, 700), - Trans(10, 95, 12, 700), - Trans(10, 96, 12, 700), - Trans(10, 97, 12, 700), - Trans(10, 100, 12, 700), - Trans(10, 102, 12, 700), - Trans(10, 104, 12, 700), - Trans(10, 106, 12, 700), - Trans(10, 107, 12, 700), - Trans(10, 110, 12, 700), - Trans(10, 111, 12, 700), - Trans(11, 5, 12, 700), - Trans(11, 29, 12, 700), - Trans(11, 35, 12, 700), - Trans(11, 38, 12, 700), - Trans(11, 42, 12, 700), - Trans(11, 47, 12, 700), - Trans(11, 48, 12, 700), - Trans(11, 49, 12, 700), - Trans(11, 52, 12, 700), - Trans(11, 59, 12, 700), - Trans(11, 63, 12, 700), - Trans(11, 64, 12, 700), - Trans(11, 65, 12, 700), - Trans(11, 68, 12, 700), - Trans(11, 69, 12, 700), - Trans(11, 70, 12, 700), - Trans(11, 72, 12, 700), - Trans(11, 76, 12, 700), - Trans(11, 79, 12, 700), - Trans(11, 80, 12, 700), - Trans(11, 98, 12, 700), - Trans(11, 99, 12, 700), - Trans(11, 103, 12, 700), - Trans(11, 105, 12, 700), - Trans(11, 108, 12, 700), - Trans(11, 109, 12, 700), - Trans(11, 110, 12, 700), - Trans(11, 111, 12, 700), - Trans(13, 30, 12, 700), - Trans(13, 42, 12, 700), - Trans(13, 44, 12, 700), - Trans(14, 5, 12, 700), - Trans(14, 35, 12, 700), - Trans(14, 38, 12, 700), - Trans(14, 42, 12, 700), - Trans(14, 44, 12, 700), - Trans(14, 111, 12, 700), - Trans(15, 5, 12, 700), - Trans(15, 30, 12, 700), - Trans(15, 42, 12, 700), - Trans(15, 44, 12, 700), - Trans(16, 5, 12, 700), - Trans(16, 13, 12, 700), - Trans(16, 38, 12, 700), + Trans(8, 39, 11, -1), + Trans(9, 13, 12, 724), + Trans(9, 39, 12, 724), + Trans(10, 5, 12, 724), + Trans(10, 52, 12, 724), + Trans(10, 54, 12, 724), + Trans(10, 55, 12, 724), + Trans(10, 56, 12, 724), + Trans(10, 62, 12, 724), + Trans(10, 63, 12, 724), + Trans(10, 67, 12, 724), + Trans(10, 68, 12, 724), + Trans(10, 82, 12, 724), + Trans(10, 94, 12, 724), + Trans(10, 95, 12, 724), + Trans(10, 96, 12, 724), + Trans(10, 97, 12, 724), + Trans(10, 98, 12, 724), + Trans(10, 101, 12, 724), + Trans(10, 103, 12, 724), + Trans(10, 105, 12, 724), + Trans(10, 107, 12, 724), + Trans(10, 108, 12, 724), + Trans(10, 111, 12, 724), + Trans(10, 112, 12, 724), + Trans(11, 5, 12, 724), + Trans(11, 30, 12, 724), + Trans(11, 36, 12, 724), + Trans(11, 39, 12, 724), + Trans(11, 43, 12, 724), + Trans(11, 48, 12, 724), + Trans(11, 49, 12, 724), + Trans(11, 50, 12, 724), + Trans(11, 53, 12, 724), + Trans(11, 60, 12, 724), + Trans(11, 64, 12, 724), + Trans(11, 65, 12, 724), + Trans(11, 66, 12, 724), + Trans(11, 69, 12, 724), + Trans(11, 70, 12, 724), + Trans(11, 71, 12, 724), + Trans(11, 73, 12, 724), + Trans(11, 77, 12, 724), + Trans(11, 80, 12, 724), + Trans(11, 81, 12, 724), + Trans(11, 99, 12, 724), + Trans(11, 100, 12, 724), + Trans(11, 104, 12, 724), + Trans(11, 106, 12, 724), + Trans(11, 109, 12, 724), + Trans(11, 110, 12, 724), + Trans(11, 111, 12, 724), + Trans(11, 112, 12, 724), + Trans(13, 31, 12, 724), + Trans(13, 43, 12, 724), + Trans(13, 45, 12, 724), + Trans(14, 5, 12, 724), + Trans(14, 36, 12, 724), + Trans(14, 39, 12, 724), + Trans(14, 43, 12, 724), + Trans(14, 45, 12, 724), + Trans(14, 112, 12, 724), + Trans(15, 5, 12, 724), + Trans(15, 31, 12, 724), + Trans(15, 43, 12, 724), + Trans(15, 45, 12, 724), + Trans(16, 5, 12, 724), + Trans(16, 13, 12, 724), + Trans(16, 39, 12, 724), ], k: 3, }, - /* 478 - "PortDeclarationListOpt" */ + /* 485 - "PortDeclarationListOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, 701), - Trans(0, 42, 2, 702), - Trans(0, 44, 2, 702), + Trans(0, 31, 1, 725), + Trans(0, 43, 2, 726), + Trans(0, 45, 2, 726), ], k: 1, }, - /* 479 - "PortDeclarationOpt" */ + /* 486 - "PortDeclarationOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 696), - Trans(0, 38, 1, 696), - Trans(0, 44, 2, 697), - Trans(0, 111, 1, 696), + Trans(0, 36, 1, 720), + Trans(0, 39, 1, 720), + Trans(0, 45, 2, 721), + Trans(0, 112, 1, 720), ], k: 1, }, - /* 480 - "Pub" */ + /* 487 - "Pub" */ LookaheadDFA { - prod0: 304, + prod0: 307, transitions: &[], k: 0, }, - /* 481 - "PubTerm" */ + /* 488 - "PubTerm" */ LookaheadDFA { - prod0: 85, + prod0: 86, transitions: &[], k: 0, }, - /* 482 - "PubToken" */ + /* 489 - "PubToken" */ LookaheadDFA { - prod0: 196, + prod0: 198, transitions: &[], k: 0, }, - /* 483 - "QuoteLBrace" */ + /* 490 - "QuoteLBrace" */ LookaheadDFA { - prod0: 246, + prod0: 249, transitions: &[], k: 0, }, - /* 484 - "QuoteLBraceTerm" */ + /* 491 - "QuoteLBraceTerm" */ LookaheadDFA { - prod0: 32, + prod0: 33, transitions: &[], k: 0, }, - /* 485 - "QuoteLBraceToken" */ + /* 492 - "QuoteLBraceToken" */ LookaheadDFA { - prod0: 139, + prod0: 141, transitions: &[], k: 0, }, - /* 486 - "RAngle" */ + /* 493 - "RAngle" */ LookaheadDFA { - prod0: 254, + prod0: 257, transitions: &[], k: 0, }, - /* 487 - "RAngleTerm" */ + /* 494 - "RAngleTerm" */ LookaheadDFA { - prod0: 36, + prod0: 37, transitions: &[], k: 0, }, - /* 488 - "RAngleToken" */ + /* 495 - "RAngleToken" */ LookaheadDFA { - prod0: 147, + prod0: 149, transitions: &[], k: 0, }, - /* 489 - "RBrace" */ + /* 496 - "RBrace" */ LookaheadDFA { - prod0: 255, + prod0: 258, transitions: &[], k: 0, }, - /* 490 - "RBraceTerm" */ + /* 497 - "RBraceTerm" */ LookaheadDFA { - prod0: 37, + prod0: 38, transitions: &[], k: 0, }, - /* 491 - "RBraceToken" */ + /* 498 - "RBraceToken" */ LookaheadDFA { - prod0: 148, + prod0: 150, transitions: &[], k: 0, }, - /* 492 - "RBracket" */ + /* 499 - "RBracket" */ LookaheadDFA { - prod0: 256, + prod0: 259, transitions: &[], k: 0, }, - /* 493 - "RBracketTerm" */ + /* 500 - "RBracketTerm" */ LookaheadDFA { - prod0: 38, + prod0: 39, transitions: &[], k: 0, }, - /* 494 - "RBracketToken" */ + /* 501 - "RBracketToken" */ LookaheadDFA { - prod0: 149, + prod0: 151, transitions: &[], k: 0, }, - /* 495 - "RParen" */ + /* 502 - "RParen" */ LookaheadDFA { - prod0: 257, + prod0: 260, transitions: &[], k: 0, }, - /* 496 - "RParenTerm" */ + /* 503 - "RParenTerm" */ LookaheadDFA { - prod0: 39, + prod0: 40, transitions: &[], k: 0, }, - /* 497 - "RParenToken" */ + /* 504 - "RParenToken" */ LookaheadDFA { - prod0: 150, + prod0: 152, transitions: &[], k: 0, }, - /* 498 - "Range" */ + /* 505 - "Range" */ LookaheadDFA { - prod0: 474, + prod0: 481, transitions: &[], k: 0, }, - /* 499 - "RangeItem" */ + /* 506 - "RangeItem" */ LookaheadDFA { - prod0: 460, + prod0: 467, transitions: &[], k: 0, }, - /* 500 - "RangeList" */ + /* 507 - "RangeList" */ LookaheadDFA { - prod0: 455, + prod0: 462, transitions: &[], k: 0, }, - /* 501 - "RangeListList" */ + /* 508 - "RangeListList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 8, -1), - Trans(1, 5, 7, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 9, -1), + Trans(1, 5, 8, -1), Trans(1, 6, 2, -1), Trans(1, 7, 2, -1), Trans(1, 8, 2, -1), @@ -10462,792 +11137,815 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(1, 25, 4, -1), Trans(1, 26, 4, -1), Trans(1, 27, 4, -1), - Trans(1, 37, 5, -1), - Trans(1, 38, 4, -1), - Trans(1, 40, 4, -1), - Trans(1, 42, 22, -1), - Trans(1, 52, 4, -1), - Trans(1, 69, 4, -1), - Trans(1, 75, 4, -1), - Trans(1, 82, 2, -1), - Trans(1, 85, 2, -1), - Trans(1, 87, 4, -1), - Trans(1, 110, 6, -1), + Trans(1, 38, 5, -1), + Trans(1, 39, 4, -1), + Trans(1, 41, 4, -1), + Trans(1, 43, 23, -1), + Trans(1, 53, 4, -1), + Trans(1, 70, 4, -1), + Trans(1, 76, 4, -1), + Trans(1, 83, 2, -1), + Trans(1, 86, 2, -1), + Trans(1, 88, 4, -1), Trans(1, 111, 6, -1), - Trans(2, 5, 3, 456), - Trans(2, 16, 3, 456), - Trans(2, 17, 3, 456), - Trans(2, 18, 3, 456), - Trans(2, 19, 3, 456), - Trans(2, 20, 3, 456), - Trans(2, 21, 3, 456), - Trans(2, 22, 3, 456), - Trans(2, 23, 3, 456), - Trans(2, 24, 3, 456), - Trans(2, 25, 3, 456), - Trans(2, 26, 3, 456), - Trans(2, 30, 3, 456), - Trans(2, 31, 3, 456), - Trans(2, 32, 3, 456), - Trans(2, 42, 3, 456), - Trans(2, 46, 3, 456), - Trans(2, 50, 3, 456), - Trans(4, 5, 3, 456), - Trans(4, 6, 3, 456), - Trans(4, 7, 3, 456), - Trans(4, 8, 3, 456), - Trans(4, 9, 3, 456), - Trans(4, 10, 3, 456), - Trans(4, 11, 3, 456), - Trans(4, 18, 3, 456), - Trans(4, 24, 3, 456), - Trans(4, 25, 3, 456), - Trans(4, 26, 3, 456), - Trans(4, 27, 3, 456), - Trans(4, 37, 3, 456), - Trans(4, 38, 3, 456), - Trans(4, 40, 3, 456), - Trans(4, 52, 3, 456), - Trans(4, 69, 3, 456), - Trans(4, 75, 3, 456), - Trans(4, 82, 3, 456), - Trans(4, 85, 3, 456), - Trans(4, 87, 3, 456), - Trans(4, 110, 3, 456), - Trans(4, 111, 3, 456), - Trans(5, 5, 3, 456), - Trans(5, 6, 3, 456), - Trans(5, 7, 3, 456), - Trans(5, 8, 3, 456), - Trans(5, 9, 3, 456), - Trans(5, 10, 3, 456), - Trans(5, 11, 3, 456), - Trans(5, 18, 3, 456), - Trans(5, 24, 3, 456), - Trans(5, 25, 3, 456), - Trans(5, 26, 3, 456), - Trans(5, 27, 3, 456), - Trans(5, 37, 3, 456), - Trans(5, 38, 3, 456), - Trans(5, 40, 3, 456), - Trans(5, 52, 3, 456), - Trans(5, 56, 3, 456), - Trans(5, 69, 3, 456), - Trans(5, 75, 3, 456), - Trans(5, 82, 3, 456), - Trans(5, 85, 3, 456), - Trans(5, 87, 3, 456), - Trans(5, 110, 3, 456), - Trans(5, 111, 3, 456), - Trans(6, 5, 3, 456), - Trans(6, 16, 3, 456), - Trans(6, 17, 3, 456), - Trans(6, 18, 3, 456), - Trans(6, 19, 3, 456), - Trans(6, 20, 3, 456), - Trans(6, 21, 3, 456), - Trans(6, 22, 3, 456), - Trans(6, 23, 3, 456), - Trans(6, 24, 3, 456), - Trans(6, 25, 3, 456), - Trans(6, 26, 3, 456), - Trans(6, 28, 3, 456), - Trans(6, 30, 3, 456), - Trans(6, 31, 3, 456), - Trans(6, 32, 3, 456), - Trans(6, 33, 3, 456), - Trans(6, 39, 3, 456), - Trans(6, 40, 3, 456), - Trans(6, 42, 3, 456), - Trans(6, 46, 3, 456), - Trans(6, 50, 3, 456), - Trans(7, 6, 3, 456), - Trans(7, 7, 3, 456), - Trans(7, 8, 3, 456), - Trans(7, 9, 3, 456), - Trans(7, 10, 3, 456), - Trans(7, 11, 3, 456), - Trans(7, 18, 3, 456), - Trans(7, 24, 3, 456), - Trans(7, 25, 3, 456), - Trans(7, 26, 3, 456), - Trans(7, 27, 3, 456), - Trans(7, 37, 3, 456), - Trans(7, 38, 3, 456), - Trans(7, 40, 3, 456), - Trans(7, 42, 21, 457), - Trans(7, 52, 3, 456), - Trans(7, 69, 3, 456), - Trans(7, 75, 3, 456), - Trans(7, 82, 3, 456), - Trans(7, 85, 3, 456), - Trans(7, 87, 3, 456), - Trans(7, 110, 3, 456), - Trans(7, 111, 3, 456), - Trans(8, 5, 9, -1), - Trans(8, 12, 10, -1), - Trans(8, 14, 10, -1), - Trans(8, 16, 10, -1), - Trans(8, 17, 10, -1), - Trans(8, 18, 10, -1), - Trans(8, 19, 10, -1), - Trans(8, 20, 10, -1), - Trans(8, 21, 10, -1), - Trans(8, 22, 10, -1), - Trans(8, 23, 10, -1), - Trans(8, 24, 10, -1), - Trans(8, 25, 10, -1), - Trans(8, 26, 10, -1), - Trans(8, 29, 11, -1), - Trans(8, 30, 12, -1), - Trans(8, 31, 10, -1), - Trans(8, 32, 10, -1), - Trans(8, 38, 13, -1), - Trans(8, 41, 14, -1), - Trans(8, 42, 15, -1), - Trans(8, 43, 16, -1), - Trans(8, 44, 17, -1), - Trans(8, 45, 18, -1), - Trans(8, 46, 10, -1), - Trans(8, 50, 19, -1), - Trans(8, 92, 10, -1), - Trans(8, 101, 20, -1), - Trans(9, 12, 21, 457), - Trans(9, 14, 21, 457), - Trans(9, 16, 21, 457), - Trans(9, 17, 21, 457), - Trans(9, 18, 21, 457), - Trans(9, 19, 21, 457), - Trans(9, 20, 21, 457), - Trans(9, 21, 21, 457), - Trans(9, 22, 21, 457), - Trans(9, 23, 21, 457), - Trans(9, 24, 21, 457), - Trans(9, 25, 21, 457), - Trans(9, 26, 21, 457), - Trans(9, 29, 21, 457), - Trans(9, 30, 21, 457), - Trans(9, 31, 21, 457), - Trans(9, 32, 21, 457), - Trans(9, 38, 21, 457), - Trans(9, 41, 21, 457), - Trans(9, 42, 21, 457), - Trans(9, 43, 21, 457), - Trans(9, 44, 21, 457), - Trans(9, 45, 21, 457), - Trans(9, 46, 21, 457), - Trans(9, 50, 21, 457), - Trans(9, 92, 21, 457), - Trans(9, 101, 21, 457), - Trans(10, 5, 21, 457), - Trans(10, 6, 21, 457), - Trans(10, 7, 21, 457), - Trans(10, 8, 21, 457), - Trans(10, 9, 21, 457), - Trans(10, 10, 21, 457), - Trans(10, 11, 21, 457), - Trans(10, 18, 21, 457), - Trans(10, 24, 21, 457), - Trans(10, 25, 21, 457), - Trans(10, 26, 21, 457), - Trans(10, 27, 21, 457), - Trans(10, 37, 21, 457), - Trans(10, 38, 21, 457), - Trans(10, 40, 21, 457), - Trans(10, 52, 21, 457), - Trans(10, 69, 21, 457), - Trans(10, 75, 21, 457), - Trans(10, 82, 21, 457), - Trans(10, 85, 21, 457), - Trans(10, 87, 21, 457), - Trans(10, 110, 21, 457), - Trans(10, 111, 21, 457), - Trans(11, 5, 21, 457), - Trans(11, 6, 21, 457), - Trans(11, 7, 21, 457), - Trans(11, 8, 21, 457), - Trans(11, 9, 21, 457), - Trans(11, 10, 21, 457), - Trans(11, 11, 21, 457), - Trans(11, 18, 21, 457), - Trans(11, 24, 21, 457), - Trans(11, 25, 21, 457), - Trans(11, 26, 21, 457), - Trans(11, 27, 21, 457), - Trans(11, 37, 21, 457), - Trans(11, 38, 21, 457), - Trans(11, 40, 21, 457), - Trans(11, 52, 21, 457), - Trans(11, 64, 21, 457), - Trans(11, 68, 21, 457), - Trans(11, 69, 21, 457), - Trans(11, 75, 21, 457), - Trans(11, 79, 21, 457), - Trans(11, 82, 21, 457), - Trans(11, 85, 21, 457), - Trans(11, 87, 21, 457), - Trans(11, 98, 21, 457), - Trans(11, 99, 21, 457), - Trans(11, 110, 21, 457), - Trans(11, 111, 21, 457), - Trans(12, 5, 21, 457), - Trans(12, 6, 21, 457), - Trans(12, 7, 21, 457), - Trans(12, 8, 21, 457), - Trans(12, 9, 21, 457), - Trans(12, 10, 21, 457), - Trans(12, 11, 21, 457), - Trans(12, 18, 21, 457), - Trans(12, 24, 21, 457), - Trans(12, 25, 21, 457), - Trans(12, 26, 21, 457), - Trans(12, 27, 21, 457), - Trans(12, 35, 21, 457), - Trans(12, 37, 21, 457), - Trans(12, 38, 21, 457), - Trans(12, 40, 21, 457), - Trans(12, 42, 21, 457), - Trans(12, 44, 21, 457), - Trans(12, 52, 21, 457), - Trans(12, 56, 21, 457), - Trans(12, 69, 21, 457), - Trans(12, 75, 21, 457), - Trans(12, 80, 21, 457), - Trans(12, 82, 21, 457), - Trans(12, 85, 21, 457), - Trans(12, 87, 21, 457), - Trans(12, 89, 21, 457), - Trans(12, 110, 21, 457), - Trans(12, 111, 21, 457), - Trans(13, 5, 21, 457), - Trans(13, 6, 21, 457), - Trans(13, 7, 21, 457), - Trans(13, 8, 21, 457), - Trans(13, 9, 21, 457), - Trans(13, 10, 21, 457), - Trans(13, 11, 21, 457), - Trans(13, 18, 21, 457), - Trans(13, 24, 21, 457), - Trans(13, 25, 21, 457), - Trans(13, 26, 21, 457), - Trans(13, 27, 21, 457), - Trans(13, 29, 21, 457), - Trans(13, 35, 21, 457), - Trans(13, 37, 21, 457), - Trans(13, 38, 21, 457), - Trans(13, 40, 21, 457), - Trans(13, 42, 21, 457), - Trans(13, 47, 21, 457), - Trans(13, 48, 21, 457), - Trans(13, 49, 21, 457), - Trans(13, 52, 21, 457), - Trans(13, 56, 21, 457), - Trans(13, 59, 21, 457), - Trans(13, 63, 21, 457), - Trans(13, 64, 21, 457), - Trans(13, 65, 21, 457), - Trans(13, 68, 21, 457), - Trans(13, 69, 21, 457), - Trans(13, 70, 21, 457), - Trans(13, 72, 21, 457), - Trans(13, 75, 21, 457), - Trans(13, 76, 21, 457), - Trans(13, 79, 21, 457), - Trans(13, 80, 21, 457), - Trans(13, 82, 21, 457), - Trans(13, 83, 21, 457), - Trans(13, 85, 21, 457), - Trans(13, 87, 21, 457), - Trans(13, 98, 21, 457), - Trans(13, 99, 21, 457), - Trans(13, 103, 21, 457), - Trans(13, 105, 21, 457), - Trans(13, 108, 21, 457), - Trans(13, 109, 21, 457), - Trans(13, 110, 21, 457), - Trans(13, 111, 21, 457), - Trans(14, 5, 21, 457), - Trans(14, 30, 21, 457), - Trans(14, 34, 21, 457), - Trans(14, 38, 21, 457), - Trans(14, 39, 21, 457), - Trans(14, 42, 21, 457), - Trans(14, 44, 21, 457), - Trans(14, 45, 21, 457), - Trans(14, 78, 21, 457), - Trans(15, 5, 21, 457), - Trans(15, 12, 21, 457), - Trans(15, 14, 21, 457), - Trans(15, 16, 21, 457), - Trans(15, 17, 21, 457), - Trans(15, 18, 21, 457), - Trans(15, 19, 21, 457), - Trans(15, 20, 21, 457), - Trans(15, 21, 21, 457), - Trans(15, 22, 21, 457), - Trans(15, 23, 21, 457), - Trans(15, 24, 21, 457), - Trans(15, 25, 21, 457), - Trans(15, 26, 21, 457), - Trans(15, 29, 21, 457), - Trans(15, 30, 21, 457), - Trans(15, 31, 21, 457), - Trans(15, 32, 21, 457), - Trans(15, 35, 21, 457), - Trans(15, 38, 21, 457), - Trans(15, 41, 21, 457), - Trans(15, 42, 21, 457), - Trans(15, 43, 21, 457), - Trans(15, 44, 21, 457), - Trans(15, 45, 21, 457), - Trans(15, 46, 21, 457), - Trans(15, 47, 21, 457), - Trans(15, 48, 21, 457), - Trans(15, 49, 21, 457), - Trans(15, 50, 21, 457), - Trans(15, 57, 21, 457), - Trans(15, 59, 21, 457), - Trans(15, 60, 21, 457), - Trans(15, 63, 21, 457), - Trans(15, 64, 21, 457), - Trans(15, 65, 21, 457), - Trans(15, 69, 21, 457), - Trans(15, 70, 21, 457), - Trans(15, 72, 21, 457), - Trans(15, 76, 21, 457), - Trans(15, 79, 21, 457), - Trans(15, 80, 21, 457), - Trans(15, 83, 21, 457), - Trans(15, 92, 21, 457), - Trans(15, 101, 21, 457), - Trans(15, 103, 21, 457), - Trans(15, 105, 21, 457), - Trans(15, 108, 21, 457), - Trans(15, 109, 21, 457), - Trans(16, 5, 21, 457), - Trans(16, 12, 21, 457), - Trans(16, 14, 21, 457), - Trans(16, 15, 21, 457), - Trans(16, 16, 21, 457), - Trans(16, 17, 21, 457), - Trans(16, 18, 21, 457), - Trans(16, 19, 21, 457), - Trans(16, 20, 21, 457), - Trans(16, 21, 21, 457), - Trans(16, 22, 21, 457), - Trans(16, 23, 21, 457), - Trans(16, 24, 21, 457), - Trans(16, 25, 21, 457), - Trans(16, 26, 21, 457), - Trans(16, 29, 21, 457), - Trans(16, 30, 21, 457), - Trans(16, 31, 21, 457), - Trans(16, 32, 21, 457), - Trans(16, 33, 21, 457), - Trans(16, 34, 21, 457), - Trans(16, 35, 21, 457), - Trans(16, 38, 21, 457), - Trans(16, 39, 21, 457), - Trans(16, 40, 21, 457), - Trans(16, 41, 21, 457), - Trans(16, 42, 21, 457), - Trans(16, 43, 21, 457), - Trans(16, 44, 21, 457), - Trans(16, 45, 21, 457), - Trans(16, 46, 21, 457), - Trans(16, 50, 21, 457), - Trans(16, 92, 21, 457), - Trans(16, 101, 21, 457), - Trans(17, 5, 21, 457), - Trans(17, 12, 21, 457), - Trans(17, 14, 21, 457), - Trans(17, 16, 21, 457), - Trans(17, 17, 21, 457), - Trans(17, 18, 21, 457), - Trans(17, 19, 21, 457), - Trans(17, 20, 21, 457), - Trans(17, 21, 21, 457), - Trans(17, 22, 21, 457), - Trans(17, 23, 21, 457), - Trans(17, 24, 21, 457), - Trans(17, 25, 21, 457), - Trans(17, 26, 21, 457), - Trans(17, 29, 21, 457), - Trans(17, 30, 21, 457), - Trans(17, 31, 21, 457), - Trans(17, 32, 21, 457), - Trans(17, 38, 21, 457), - Trans(17, 40, 21, 457), - Trans(17, 41, 21, 457), - Trans(17, 42, 21, 457), - Trans(17, 43, 21, 457), - Trans(17, 44, 21, 457), - Trans(17, 45, 21, 457), - Trans(17, 46, 21, 457), - Trans(17, 50, 21, 457), - Trans(17, 92, 21, 457), - Trans(17, 101, 21, 457), - Trans(18, 5, 21, 457), - Trans(18, 6, 21, 457), - Trans(18, 7, 21, 457), - Trans(18, 8, 21, 457), - Trans(18, 9, 21, 457), - Trans(18, 10, 21, 457), - Trans(18, 11, 21, 457), - Trans(18, 18, 21, 457), - Trans(18, 24, 21, 457), - Trans(18, 25, 21, 457), - Trans(18, 26, 21, 457), - Trans(18, 27, 21, 457), - Trans(18, 29, 21, 457), - Trans(18, 35, 21, 457), - Trans(18, 37, 21, 457), - Trans(18, 38, 21, 457), - Trans(18, 40, 21, 457), - Trans(18, 42, 21, 457), - Trans(18, 47, 21, 457), - Trans(18, 48, 21, 457), - Trans(18, 49, 21, 457), - Trans(18, 52, 21, 457), - Trans(18, 56, 21, 457), - Trans(18, 59, 21, 457), - Trans(18, 60, 21, 457), - Trans(18, 63, 21, 457), - Trans(18, 64, 21, 457), - Trans(18, 65, 21, 457), - Trans(18, 68, 21, 457), - Trans(18, 69, 21, 457), - Trans(18, 70, 21, 457), - Trans(18, 72, 21, 457), - Trans(18, 75, 21, 457), - Trans(18, 76, 21, 457), - Trans(18, 79, 21, 457), - Trans(18, 80, 21, 457), - Trans(18, 82, 21, 457), - Trans(18, 83, 21, 457), - Trans(18, 85, 21, 457), - Trans(18, 87, 21, 457), - Trans(18, 98, 21, 457), - Trans(18, 99, 21, 457), - Trans(18, 103, 21, 457), - Trans(18, 105, 21, 457), - Trans(18, 108, 21, 457), - Trans(18, 109, 21, 457), - Trans(18, 110, 21, 457), - Trans(18, 111, 21, 457), - Trans(19, 5, 21, 457), - Trans(19, 110, 21, 457), - Trans(19, 111, 21, 457), - Trans(20, 5, 21, 457), - Trans(20, 6, 21, 457), - Trans(20, 7, 21, 457), - Trans(20, 8, 21, 457), - Trans(20, 9, 21, 457), - Trans(20, 10, 21, 457), - Trans(20, 11, 21, 457), - Trans(20, 15, 21, 457), - Trans(20, 18, 21, 457), - Trans(20, 24, 21, 457), - Trans(20, 25, 21, 457), - Trans(20, 26, 21, 457), - Trans(20, 27, 21, 457), - Trans(20, 37, 21, 457), - Trans(20, 38, 21, 457), - Trans(20, 40, 21, 457), - Trans(20, 52, 21, 457), - Trans(20, 69, 21, 457), - Trans(20, 75, 21, 457), - Trans(20, 82, 21, 457), - Trans(20, 85, 21, 457), - Trans(20, 87, 21, 457), - Trans(20, 110, 21, 457), - Trans(20, 111, 21, 457), - Trans(22, 5, 21, 457), - Trans(22, 12, 21, 457), - Trans(22, 14, 21, 457), - Trans(22, 16, 21, 457), - Trans(22, 17, 21, 457), - Trans(22, 18, 21, 457), - Trans(22, 19, 21, 457), - Trans(22, 20, 21, 457), - Trans(22, 21, 21, 457), - Trans(22, 22, 21, 457), - Trans(22, 23, 21, 457), - Trans(22, 24, 21, 457), - Trans(22, 25, 21, 457), - Trans(22, 26, 21, 457), - Trans(22, 29, 21, 457), - Trans(22, 30, 21, 457), - Trans(22, 31, 21, 457), - Trans(22, 32, 21, 457), - Trans(22, 38, 21, 457), - Trans(22, 41, 21, 457), - Trans(22, 42, 21, 457), - Trans(22, 43, 21, 457), - Trans(22, 44, 21, 457), - Trans(22, 45, 21, 457), - Trans(22, 46, 21, 457), - Trans(22, 50, 21, 457), - Trans(22, 92, 21, 457), - Trans(22, 101, 21, 457), + Trans(1, 112, 7, -1), + Trans(2, 5, 3, 463), + Trans(2, 16, 3, 463), + Trans(2, 17, 3, 463), + Trans(2, 18, 3, 463), + Trans(2, 19, 3, 463), + Trans(2, 20, 3, 463), + Trans(2, 21, 3, 463), + Trans(2, 22, 3, 463), + Trans(2, 23, 3, 463), + Trans(2, 24, 3, 463), + Trans(2, 25, 3, 463), + Trans(2, 26, 3, 463), + Trans(2, 31, 3, 463), + Trans(2, 32, 3, 463), + Trans(2, 33, 3, 463), + Trans(2, 43, 3, 463), + Trans(2, 47, 3, 463), + Trans(2, 51, 3, 463), + Trans(4, 5, 3, 463), + Trans(4, 6, 3, 463), + Trans(4, 7, 3, 463), + Trans(4, 8, 3, 463), + Trans(4, 9, 3, 463), + Trans(4, 10, 3, 463), + Trans(4, 11, 3, 463), + Trans(4, 18, 3, 463), + Trans(4, 24, 3, 463), + Trans(4, 25, 3, 463), + Trans(4, 26, 3, 463), + Trans(4, 27, 3, 463), + Trans(4, 38, 3, 463), + Trans(4, 39, 3, 463), + Trans(4, 41, 3, 463), + Trans(4, 53, 3, 463), + Trans(4, 70, 3, 463), + Trans(4, 76, 3, 463), + Trans(4, 83, 3, 463), + Trans(4, 86, 3, 463), + Trans(4, 88, 3, 463), + Trans(4, 111, 3, 463), + Trans(4, 112, 3, 463), + Trans(5, 5, 3, 463), + Trans(5, 6, 3, 463), + Trans(5, 7, 3, 463), + Trans(5, 8, 3, 463), + Trans(5, 9, 3, 463), + Trans(5, 10, 3, 463), + Trans(5, 11, 3, 463), + Trans(5, 18, 3, 463), + Trans(5, 24, 3, 463), + Trans(5, 25, 3, 463), + Trans(5, 26, 3, 463), + Trans(5, 27, 3, 463), + Trans(5, 38, 3, 463), + Trans(5, 39, 3, 463), + Trans(5, 41, 3, 463), + Trans(5, 53, 3, 463), + Trans(5, 57, 3, 463), + Trans(5, 70, 3, 463), + Trans(5, 76, 3, 463), + Trans(5, 83, 3, 463), + Trans(5, 86, 3, 463), + Trans(5, 88, 3, 463), + Trans(5, 111, 3, 463), + Trans(5, 112, 3, 463), + Trans(6, 5, 3, 463), + Trans(6, 16, 3, 463), + Trans(6, 17, 3, 463), + Trans(6, 18, 3, 463), + Trans(6, 19, 3, 463), + Trans(6, 20, 3, 463), + Trans(6, 21, 3, 463), + Trans(6, 22, 3, 463), + Trans(6, 23, 3, 463), + Trans(6, 24, 3, 463), + Trans(6, 25, 3, 463), + Trans(6, 26, 3, 463), + Trans(6, 29, 3, 463), + Trans(6, 31, 3, 463), + Trans(6, 32, 3, 463), + Trans(6, 33, 3, 463), + Trans(6, 34, 3, 463), + Trans(6, 40, 3, 463), + Trans(6, 41, 3, 463), + Trans(6, 43, 3, 463), + Trans(6, 47, 3, 463), + Trans(6, 51, 3, 463), + Trans(7, 5, 3, 463), + Trans(7, 16, 3, 463), + Trans(7, 17, 3, 463), + Trans(7, 18, 3, 463), + Trans(7, 19, 3, 463), + Trans(7, 20, 3, 463), + Trans(7, 21, 3, 463), + Trans(7, 22, 3, 463), + Trans(7, 23, 3, 463), + Trans(7, 24, 3, 463), + Trans(7, 25, 3, 463), + Trans(7, 26, 3, 463), + Trans(7, 28, 3, 463), + Trans(7, 29, 3, 463), + Trans(7, 31, 3, 463), + Trans(7, 32, 3, 463), + Trans(7, 33, 3, 463), + Trans(7, 34, 3, 463), + Trans(7, 40, 3, 463), + Trans(7, 41, 3, 463), + Trans(7, 43, 3, 463), + Trans(7, 47, 3, 463), + Trans(7, 51, 3, 463), + Trans(8, 6, 3, 463), + Trans(8, 7, 3, 463), + Trans(8, 8, 3, 463), + Trans(8, 9, 3, 463), + Trans(8, 10, 3, 463), + Trans(8, 11, 3, 463), + Trans(8, 18, 3, 463), + Trans(8, 24, 3, 463), + Trans(8, 25, 3, 463), + Trans(8, 26, 3, 463), + Trans(8, 27, 3, 463), + Trans(8, 38, 3, 463), + Trans(8, 39, 3, 463), + Trans(8, 41, 3, 463), + Trans(8, 43, 22, 464), + Trans(8, 53, 3, 463), + Trans(8, 70, 3, 463), + Trans(8, 76, 3, 463), + Trans(8, 83, 3, 463), + Trans(8, 86, 3, 463), + Trans(8, 88, 3, 463), + Trans(8, 111, 3, 463), + Trans(8, 112, 3, 463), + Trans(9, 5, 10, -1), + Trans(9, 12, 11, -1), + Trans(9, 14, 11, -1), + Trans(9, 16, 11, -1), + Trans(9, 17, 11, -1), + Trans(9, 18, 11, -1), + Trans(9, 19, 11, -1), + Trans(9, 20, 11, -1), + Trans(9, 21, 11, -1), + Trans(9, 22, 11, -1), + Trans(9, 23, 11, -1), + Trans(9, 24, 11, -1), + Trans(9, 25, 11, -1), + Trans(9, 26, 11, -1), + Trans(9, 30, 12, -1), + Trans(9, 31, 13, -1), + Trans(9, 32, 11, -1), + Trans(9, 33, 11, -1), + Trans(9, 39, 14, -1), + Trans(9, 42, 15, -1), + Trans(9, 43, 16, -1), + Trans(9, 44, 17, -1), + Trans(9, 45, 18, -1), + Trans(9, 46, 19, -1), + Trans(9, 47, 11, -1), + Trans(9, 51, 20, -1), + Trans(9, 93, 11, -1), + Trans(9, 102, 21, -1), + Trans(10, 12, 22, 464), + Trans(10, 14, 22, 464), + Trans(10, 16, 22, 464), + Trans(10, 17, 22, 464), + Trans(10, 18, 22, 464), + Trans(10, 19, 22, 464), + Trans(10, 20, 22, 464), + Trans(10, 21, 22, 464), + Trans(10, 22, 22, 464), + Trans(10, 23, 22, 464), + Trans(10, 24, 22, 464), + Trans(10, 25, 22, 464), + Trans(10, 26, 22, 464), + Trans(10, 30, 22, 464), + Trans(10, 31, 22, 464), + Trans(10, 32, 22, 464), + Trans(10, 33, 22, 464), + Trans(10, 39, 22, 464), + Trans(10, 42, 22, 464), + Trans(10, 43, 22, 464), + Trans(10, 44, 22, 464), + Trans(10, 45, 22, 464), + Trans(10, 46, 22, 464), + Trans(10, 47, 22, 464), + Trans(10, 51, 22, 464), + Trans(10, 93, 22, 464), + Trans(10, 102, 22, 464), + Trans(11, 5, 22, 464), + Trans(11, 6, 22, 464), + Trans(11, 7, 22, 464), + Trans(11, 8, 22, 464), + Trans(11, 9, 22, 464), + Trans(11, 10, 22, 464), + Trans(11, 11, 22, 464), + Trans(11, 18, 22, 464), + Trans(11, 24, 22, 464), + Trans(11, 25, 22, 464), + Trans(11, 26, 22, 464), + Trans(11, 27, 22, 464), + Trans(11, 38, 22, 464), + Trans(11, 39, 22, 464), + Trans(11, 41, 22, 464), + Trans(11, 53, 22, 464), + Trans(11, 70, 22, 464), + Trans(11, 76, 22, 464), + Trans(11, 83, 22, 464), + Trans(11, 86, 22, 464), + Trans(11, 88, 22, 464), + Trans(11, 111, 22, 464), + Trans(11, 112, 22, 464), + Trans(12, 5, 22, 464), + Trans(12, 6, 22, 464), + Trans(12, 7, 22, 464), + Trans(12, 8, 22, 464), + Trans(12, 9, 22, 464), + Trans(12, 10, 22, 464), + Trans(12, 11, 22, 464), + Trans(12, 18, 22, 464), + Trans(12, 24, 22, 464), + Trans(12, 25, 22, 464), + Trans(12, 26, 22, 464), + Trans(12, 27, 22, 464), + Trans(12, 38, 22, 464), + Trans(12, 39, 22, 464), + Trans(12, 41, 22, 464), + Trans(12, 53, 22, 464), + Trans(12, 65, 22, 464), + Trans(12, 69, 22, 464), + Trans(12, 70, 22, 464), + Trans(12, 76, 22, 464), + Trans(12, 80, 22, 464), + Trans(12, 83, 22, 464), + Trans(12, 86, 22, 464), + Trans(12, 88, 22, 464), + Trans(12, 99, 22, 464), + Trans(12, 100, 22, 464), + Trans(12, 111, 22, 464), + Trans(12, 112, 22, 464), + Trans(13, 5, 22, 464), + Trans(13, 6, 22, 464), + Trans(13, 7, 22, 464), + Trans(13, 8, 22, 464), + Trans(13, 9, 22, 464), + Trans(13, 10, 22, 464), + Trans(13, 11, 22, 464), + Trans(13, 18, 22, 464), + Trans(13, 24, 22, 464), + Trans(13, 25, 22, 464), + Trans(13, 26, 22, 464), + Trans(13, 27, 22, 464), + Trans(13, 36, 22, 464), + Trans(13, 38, 22, 464), + Trans(13, 39, 22, 464), + Trans(13, 41, 22, 464), + Trans(13, 43, 22, 464), + Trans(13, 45, 22, 464), + Trans(13, 53, 22, 464), + Trans(13, 57, 22, 464), + Trans(13, 70, 22, 464), + Trans(13, 76, 22, 464), + Trans(13, 81, 22, 464), + Trans(13, 83, 22, 464), + Trans(13, 86, 22, 464), + Trans(13, 88, 22, 464), + Trans(13, 90, 22, 464), + Trans(13, 111, 22, 464), + Trans(13, 112, 22, 464), + Trans(14, 5, 22, 464), + Trans(14, 6, 22, 464), + Trans(14, 7, 22, 464), + Trans(14, 8, 22, 464), + Trans(14, 9, 22, 464), + Trans(14, 10, 22, 464), + Trans(14, 11, 22, 464), + Trans(14, 18, 22, 464), + Trans(14, 24, 22, 464), + Trans(14, 25, 22, 464), + Trans(14, 26, 22, 464), + Trans(14, 27, 22, 464), + Trans(14, 30, 22, 464), + Trans(14, 36, 22, 464), + Trans(14, 38, 22, 464), + Trans(14, 39, 22, 464), + Trans(14, 41, 22, 464), + Trans(14, 43, 22, 464), + Trans(14, 48, 22, 464), + Trans(14, 49, 22, 464), + Trans(14, 50, 22, 464), + Trans(14, 53, 22, 464), + Trans(14, 57, 22, 464), + Trans(14, 60, 22, 464), + Trans(14, 64, 22, 464), + Trans(14, 65, 22, 464), + Trans(14, 66, 22, 464), + Trans(14, 69, 22, 464), + Trans(14, 70, 22, 464), + Trans(14, 71, 22, 464), + Trans(14, 73, 22, 464), + Trans(14, 76, 22, 464), + Trans(14, 77, 22, 464), + Trans(14, 80, 22, 464), + Trans(14, 81, 22, 464), + Trans(14, 83, 22, 464), + Trans(14, 84, 22, 464), + Trans(14, 86, 22, 464), + Trans(14, 88, 22, 464), + Trans(14, 99, 22, 464), + Trans(14, 100, 22, 464), + Trans(14, 104, 22, 464), + Trans(14, 106, 22, 464), + Trans(14, 109, 22, 464), + Trans(14, 110, 22, 464), + Trans(14, 111, 22, 464), + Trans(14, 112, 22, 464), + Trans(15, 5, 22, 464), + Trans(15, 31, 22, 464), + Trans(15, 35, 22, 464), + Trans(15, 39, 22, 464), + Trans(15, 40, 22, 464), + Trans(15, 43, 22, 464), + Trans(15, 45, 22, 464), + Trans(15, 46, 22, 464), + Trans(15, 79, 22, 464), + Trans(16, 5, 22, 464), + Trans(16, 12, 22, 464), + Trans(16, 14, 22, 464), + Trans(16, 16, 22, 464), + Trans(16, 17, 22, 464), + Trans(16, 18, 22, 464), + Trans(16, 19, 22, 464), + Trans(16, 20, 22, 464), + Trans(16, 21, 22, 464), + Trans(16, 22, 22, 464), + Trans(16, 23, 22, 464), + Trans(16, 24, 22, 464), + Trans(16, 25, 22, 464), + Trans(16, 26, 22, 464), + Trans(16, 30, 22, 464), + Trans(16, 31, 22, 464), + Trans(16, 32, 22, 464), + Trans(16, 33, 22, 464), + Trans(16, 36, 22, 464), + Trans(16, 39, 22, 464), + Trans(16, 42, 22, 464), + Trans(16, 43, 22, 464), + Trans(16, 44, 22, 464), + Trans(16, 45, 22, 464), + Trans(16, 46, 22, 464), + Trans(16, 47, 22, 464), + Trans(16, 48, 22, 464), + Trans(16, 49, 22, 464), + Trans(16, 50, 22, 464), + Trans(16, 51, 22, 464), + Trans(16, 58, 22, 464), + Trans(16, 60, 22, 464), + Trans(16, 61, 22, 464), + Trans(16, 64, 22, 464), + Trans(16, 65, 22, 464), + Trans(16, 66, 22, 464), + Trans(16, 70, 22, 464), + Trans(16, 71, 22, 464), + Trans(16, 73, 22, 464), + Trans(16, 77, 22, 464), + Trans(16, 80, 22, 464), + Trans(16, 81, 22, 464), + Trans(16, 84, 22, 464), + Trans(16, 93, 22, 464), + Trans(16, 102, 22, 464), + Trans(16, 104, 22, 464), + Trans(16, 106, 22, 464), + Trans(16, 109, 22, 464), + Trans(16, 110, 22, 464), + Trans(17, 5, 22, 464), + Trans(17, 12, 22, 464), + Trans(17, 14, 22, 464), + Trans(17, 15, 22, 464), + Trans(17, 16, 22, 464), + Trans(17, 17, 22, 464), + Trans(17, 18, 22, 464), + Trans(17, 19, 22, 464), + Trans(17, 20, 22, 464), + Trans(17, 21, 22, 464), + Trans(17, 22, 22, 464), + Trans(17, 23, 22, 464), + Trans(17, 24, 22, 464), + Trans(17, 25, 22, 464), + Trans(17, 26, 22, 464), + Trans(17, 30, 22, 464), + Trans(17, 31, 22, 464), + Trans(17, 32, 22, 464), + Trans(17, 33, 22, 464), + Trans(17, 34, 22, 464), + Trans(17, 35, 22, 464), + Trans(17, 36, 22, 464), + Trans(17, 39, 22, 464), + Trans(17, 40, 22, 464), + Trans(17, 41, 22, 464), + Trans(17, 42, 22, 464), + Trans(17, 43, 22, 464), + Trans(17, 44, 22, 464), + Trans(17, 45, 22, 464), + Trans(17, 46, 22, 464), + Trans(17, 47, 22, 464), + Trans(17, 51, 22, 464), + Trans(17, 93, 22, 464), + Trans(17, 102, 22, 464), + Trans(18, 5, 22, 464), + Trans(18, 12, 22, 464), + Trans(18, 14, 22, 464), + Trans(18, 16, 22, 464), + Trans(18, 17, 22, 464), + Trans(18, 18, 22, 464), + Trans(18, 19, 22, 464), + Trans(18, 20, 22, 464), + Trans(18, 21, 22, 464), + Trans(18, 22, 22, 464), + Trans(18, 23, 22, 464), + Trans(18, 24, 22, 464), + Trans(18, 25, 22, 464), + Trans(18, 26, 22, 464), + Trans(18, 30, 22, 464), + Trans(18, 31, 22, 464), + Trans(18, 32, 22, 464), + Trans(18, 33, 22, 464), + Trans(18, 39, 22, 464), + Trans(18, 41, 22, 464), + Trans(18, 42, 22, 464), + Trans(18, 43, 22, 464), + Trans(18, 44, 22, 464), + Trans(18, 45, 22, 464), + Trans(18, 46, 22, 464), + Trans(18, 47, 22, 464), + Trans(18, 51, 22, 464), + Trans(18, 93, 22, 464), + Trans(18, 102, 22, 464), + Trans(19, 5, 22, 464), + Trans(19, 6, 22, 464), + Trans(19, 7, 22, 464), + Trans(19, 8, 22, 464), + Trans(19, 9, 22, 464), + Trans(19, 10, 22, 464), + Trans(19, 11, 22, 464), + Trans(19, 18, 22, 464), + Trans(19, 24, 22, 464), + Trans(19, 25, 22, 464), + Trans(19, 26, 22, 464), + Trans(19, 27, 22, 464), + Trans(19, 30, 22, 464), + Trans(19, 36, 22, 464), + Trans(19, 38, 22, 464), + Trans(19, 39, 22, 464), + Trans(19, 41, 22, 464), + Trans(19, 43, 22, 464), + Trans(19, 48, 22, 464), + Trans(19, 49, 22, 464), + Trans(19, 50, 22, 464), + Trans(19, 53, 22, 464), + Trans(19, 57, 22, 464), + Trans(19, 60, 22, 464), + Trans(19, 61, 22, 464), + Trans(19, 64, 22, 464), + Trans(19, 65, 22, 464), + Trans(19, 66, 22, 464), + Trans(19, 69, 22, 464), + Trans(19, 70, 22, 464), + Trans(19, 71, 22, 464), + Trans(19, 73, 22, 464), + Trans(19, 76, 22, 464), + Trans(19, 77, 22, 464), + Trans(19, 80, 22, 464), + Trans(19, 81, 22, 464), + Trans(19, 83, 22, 464), + Trans(19, 84, 22, 464), + Trans(19, 86, 22, 464), + Trans(19, 88, 22, 464), + Trans(19, 99, 22, 464), + Trans(19, 100, 22, 464), + Trans(19, 104, 22, 464), + Trans(19, 106, 22, 464), + Trans(19, 109, 22, 464), + Trans(19, 110, 22, 464), + Trans(19, 111, 22, 464), + Trans(19, 112, 22, 464), + Trans(20, 5, 22, 464), + Trans(20, 111, 22, 464), + Trans(20, 112, 22, 464), + Trans(21, 5, 22, 464), + Trans(21, 6, 22, 464), + Trans(21, 7, 22, 464), + Trans(21, 8, 22, 464), + Trans(21, 9, 22, 464), + Trans(21, 10, 22, 464), + Trans(21, 11, 22, 464), + Trans(21, 15, 22, 464), + Trans(21, 18, 22, 464), + Trans(21, 24, 22, 464), + Trans(21, 25, 22, 464), + Trans(21, 26, 22, 464), + Trans(21, 27, 22, 464), + Trans(21, 38, 22, 464), + Trans(21, 39, 22, 464), + Trans(21, 41, 22, 464), + Trans(21, 53, 22, 464), + Trans(21, 70, 22, 464), + Trans(21, 76, 22, 464), + Trans(21, 83, 22, 464), + Trans(21, 86, 22, 464), + Trans(21, 88, 22, 464), + Trans(21, 111, 22, 464), + Trans(21, 112, 22, 464), + Trans(23, 5, 22, 464), + Trans(23, 12, 22, 464), + Trans(23, 14, 22, 464), + Trans(23, 16, 22, 464), + Trans(23, 17, 22, 464), + Trans(23, 18, 22, 464), + Trans(23, 19, 22, 464), + Trans(23, 20, 22, 464), + Trans(23, 21, 22, 464), + Trans(23, 22, 22, 464), + Trans(23, 23, 22, 464), + Trans(23, 24, 22, 464), + Trans(23, 25, 22, 464), + Trans(23, 26, 22, 464), + Trans(23, 30, 22, 464), + Trans(23, 31, 22, 464), + Trans(23, 32, 22, 464), + Trans(23, 33, 22, 464), + Trans(23, 39, 22, 464), + Trans(23, 42, 22, 464), + Trans(23, 43, 22, 464), + Trans(23, 44, 22, 464), + Trans(23, 45, 22, 464), + Trans(23, 46, 22, 464), + Trans(23, 47, 22, 464), + Trans(23, 51, 22, 464), + Trans(23, 93, 22, 464), + Trans(23, 102, 22, 464), ], k: 3, }, - /* 502 - "RangeListOpt" */ + /* 509 - "RangeListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 458), Trans(0, 42, 2, 459)], + transitions: &[Trans(0, 31, 1, 465), Trans(0, 43, 2, 466)], k: 1, }, - /* 503 - "RangeOperator" */ + /* 510 - "RangeOperator" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 31, 2, 478), Trans(0, 32, 1, 477)], + transitions: &[Trans(0, 32, 2, 485), Trans(0, 33, 1, 484)], k: 1, }, - /* 504 - "RangeOpt" */ + /* 511 - "RangeOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 29, 2, 476), - Trans(0, 30, 2, 476), - Trans(0, 31, 1, 475), - Trans(0, 32, 1, 475), - Trans(0, 38, 2, 476), - Trans(0, 42, 2, 476), - Trans(0, 101, 2, 476), + Trans(0, 30, 2, 483), + Trans(0, 31, 2, 483), + Trans(0, 32, 1, 482), + Trans(0, 33, 1, 482), + Trans(0, 39, 2, 483), + Trans(0, 43, 2, 483), + Trans(0, 102, 2, 483), ], k: 1, }, - /* 505 - "RealNumber" */ + /* 512 - "RealNumber" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 7, 2, 331), Trans(0, 8, 1, 330)], + transitions: &[Trans(0, 7, 2, 334), Trans(0, 8, 1, 333)], k: 1, }, - /* 506 - "Ref" */ + /* 513 - "Ref" */ LookaheadDFA { - prod0: 305, + prod0: 308, transitions: &[], k: 0, }, - /* 507 - "RefTerm" */ + /* 514 - "RefTerm" */ LookaheadDFA { - prod0: 86, + prod0: 87, transitions: &[], k: 0, }, - /* 508 - "RefToken" */ + /* 515 - "RefToken" */ LookaheadDFA { - prod0: 197, + prod0: 199, transitions: &[], k: 0, }, - /* 509 - "Repeat" */ + /* 516 - "Repeat" */ LookaheadDFA { - prod0: 306, + prod0: 309, transitions: &[], k: 0, }, - /* 510 - "RepeatTerm" */ + /* 517 - "RepeatTerm" */ LookaheadDFA { - prod0: 87, + prod0: 88, transitions: &[], k: 0, }, - /* 511 - "RepeatToken" */ + /* 518 - "RepeatToken" */ LookaheadDFA { - prod0: 198, + prod0: 200, transitions: &[], k: 0, }, - /* 512 - "Reset" */ + /* 519 - "Reset" */ LookaheadDFA { - prod0: 307, + prod0: 310, transitions: &[], k: 0, }, - /* 513 - "ResetAsyncHigh" */ + /* 520 - "ResetAsyncHigh" */ LookaheadDFA { - prod0: 308, + prod0: 311, transitions: &[], k: 0, }, - /* 514 - "ResetAsyncHighTerm" */ + /* 521 - "ResetAsyncHighTerm" */ LookaheadDFA { - prod0: 89, + prod0: 90, transitions: &[], k: 0, }, - /* 515 - "ResetAsyncHighToken" */ + /* 522 - "ResetAsyncHighToken" */ LookaheadDFA { - prod0: 200, + prod0: 202, transitions: &[], k: 0, }, - /* 516 - "ResetAsyncLow" */ + /* 523 - "ResetAsyncLow" */ LookaheadDFA { - prod0: 309, + prod0: 312, transitions: &[], k: 0, }, - /* 517 - "ResetAsyncLowTerm" */ + /* 524 - "ResetAsyncLowTerm" */ LookaheadDFA { - prod0: 90, + prod0: 91, transitions: &[], k: 0, }, - /* 518 - "ResetAsyncLowToken" */ + /* 525 - "ResetAsyncLowToken" */ LookaheadDFA { - prod0: 201, + prod0: 203, transitions: &[], k: 0, }, - /* 519 - "ResetSyncHigh" */ + /* 526 - "ResetSyncHigh" */ LookaheadDFA { - prod0: 310, + prod0: 313, transitions: &[], k: 0, }, - /* 520 - "ResetSyncHighTerm" */ + /* 527 - "ResetSyncHighTerm" */ LookaheadDFA { - prod0: 91, + prod0: 92, transitions: &[], k: 0, }, - /* 521 - "ResetSyncHighToken" */ + /* 528 - "ResetSyncHighToken" */ LookaheadDFA { - prod0: 202, + prod0: 204, transitions: &[], k: 0, }, - /* 522 - "ResetSyncLow" */ + /* 529 - "ResetSyncLow" */ LookaheadDFA { - prod0: 311, + prod0: 314, transitions: &[], k: 0, }, - /* 523 - "ResetSyncLowTerm" */ + /* 530 - "ResetSyncLowTerm" */ LookaheadDFA { - prod0: 92, + prod0: 93, transitions: &[], k: 0, }, - /* 524 - "ResetSyncLowToken" */ + /* 531 - "ResetSyncLowToken" */ LookaheadDFA { - prod0: 203, + prod0: 205, transitions: &[], k: 0, }, - /* 525 - "ResetTerm" */ + /* 532 - "ResetTerm" */ LookaheadDFA { - prod0: 88, + prod0: 89, transitions: &[], k: 0, }, - /* 526 - "ResetToken" */ + /* 533 - "ResetToken" */ LookaheadDFA { - prod0: 199, + prod0: 201, transitions: &[], k: 0, }, - /* 527 - "Return" */ + /* 534 - "Return" */ LookaheadDFA { - prod0: 312, + prod0: 315, transitions: &[], k: 0, }, - /* 528 - "ReturnStatement" */ + /* 535 - "ReturnStatement" */ LookaheadDFA { - prod0: 547, + prod0: 554, transitions: &[], k: 0, }, - /* 529 - "ReturnTerm" */ + /* 536 - "ReturnTerm" */ LookaheadDFA { - prod0: 93, + prod0: 94, transitions: &[], k: 0, }, - /* 530 - "ReturnToken" */ + /* 537 - "ReturnToken" */ LookaheadDFA { - prod0: 204, + prod0: 206, transitions: &[], k: 0, }, - /* 531 - "ScalarType" */ + /* 538 - "ScalarType" */ LookaheadDFA { - prod0: 502, + prod0: 509, transitions: &[], k: 0, }, - /* 532 - "ScalarTypeGroup" */ + /* 539 - "ScalarTypeGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 51, 1, 503), - Trans(0, 53, 1, 503), - Trans(0, 54, 1, 503), - Trans(0, 55, 1, 503), - Trans(0, 61, 2, 504), - Trans(0, 62, 2, 504), - Trans(0, 66, 2, 504), - Trans(0, 67, 2, 504), - Trans(0, 81, 1, 503), - Trans(0, 93, 1, 503), - Trans(0, 94, 1, 503), - Trans(0, 95, 1, 503), - Trans(0, 96, 1, 503), - Trans(0, 97, 1, 503), - Trans(0, 102, 2, 504), - Trans(0, 106, 2, 504), - Trans(0, 107, 2, 504), - Trans(0, 110, 1, 503), - Trans(0, 111, 1, 503), + Trans(0, 52, 1, 510), + Trans(0, 54, 1, 510), + Trans(0, 55, 1, 510), + Trans(0, 56, 1, 510), + Trans(0, 62, 2, 511), + Trans(0, 63, 2, 511), + Trans(0, 67, 2, 511), + Trans(0, 68, 2, 511), + Trans(0, 82, 1, 510), + Trans(0, 94, 1, 510), + Trans(0, 95, 1, 510), + Trans(0, 96, 1, 510), + Trans(0, 97, 1, 510), + Trans(0, 98, 1, 510), + Trans(0, 103, 2, 511), + Trans(0, 107, 2, 511), + Trans(0, 108, 2, 511), + Trans(0, 111, 1, 510), + Trans(0, 112, 1, 510), ], k: 1, }, - /* 533 - "ScalarTypeList" */ + /* 540 - "ScalarTypeList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 51, 2, 506), - Trans(0, 53, 2, 506), - Trans(0, 54, 2, 506), - Trans(0, 55, 2, 506), - Trans(0, 61, 2, 506), - Trans(0, 62, 2, 506), - Trans(0, 66, 2, 506), - Trans(0, 67, 2, 506), - Trans(0, 81, 2, 506), - Trans(0, 93, 2, 506), - Trans(0, 94, 2, 506), - Trans(0, 95, 2, 506), - Trans(0, 96, 2, 506), - Trans(0, 97, 2, 506), - Trans(0, 100, 1, 505), - Trans(0, 102, 2, 506), - Trans(0, 104, 1, 505), - Trans(0, 106, 2, 506), - Trans(0, 107, 2, 506), - Trans(0, 110, 2, 506), - Trans(0, 111, 2, 506), + Trans(0, 52, 2, 513), + Trans(0, 54, 2, 513), + Trans(0, 55, 2, 513), + Trans(0, 56, 2, 513), + Trans(0, 62, 2, 513), + Trans(0, 63, 2, 513), + Trans(0, 67, 2, 513), + Trans(0, 68, 2, 513), + Trans(0, 82, 2, 513), + Trans(0, 94, 2, 513), + Trans(0, 95, 2, 513), + Trans(0, 96, 2, 513), + Trans(0, 97, 2, 513), + Trans(0, 98, 2, 513), + Trans(0, 101, 1, 512), + Trans(0, 103, 2, 513), + Trans(0, 105, 1, 512), + Trans(0, 107, 2, 513), + Trans(0, 108, 2, 513), + Trans(0, 111, 2, 513), + Trans(0, 112, 2, 513), ], k: 1, }, - /* 534 - "ScopedIdentifier" */ + /* 541 - "ScopedIdentifier" */ LookaheadDFA { - prod0: 339, + prod0: 342, transitions: &[], k: 0, }, - /* 535 - "ScopedIdentifierGroup" */ + /* 542 - "ScopedIdentifierGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 110, 1, 340), Trans(0, 111, 2, 341)], + transitions: &[Trans(0, 111, 1, 343), Trans(0, 112, 2, 344)], k: 1, }, - /* 536 - "ScopedIdentifierList" */ + /* 543 - "ScopedIdentifierList" */ LookaheadDFA { prod0: -1, transitions: &[ @@ -11265,374 +11963,404 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(0, 24, 7, -1), Trans(0, 25, 7, -1), Trans(0, 26, 7, -1), - Trans(0, 28, 1, -1), - Trans(0, 29, 8, -1), - Trans(0, 30, 9, -1), - Trans(0, 31, 10, -1), + Trans(0, 29, 1, -1), + Trans(0, 30, 8, -1), + Trans(0, 31, 9, -1), Trans(0, 32, 10, -1), - Trans(0, 33, 11, -1), - Trans(0, 34, 12, -1), - Trans(0, 35, 13, -1), - Trans(0, 36, 14, -1), - Trans(0, 38, 15, -1), - Trans(0, 39, 16, -1), - Trans(0, 40, 17, -1), - Trans(0, 41, 18, -1), - Trans(0, 42, 19, -1), - Trans(0, 43, 20, -1), - Trans(0, 44, 21, -1), - Trans(0, 45, 22, -1), - Trans(0, 46, 7, -1), - Trans(0, 50, 23, -1), - Trans(0, 78, 24, -1), - Trans(0, 92, 25, -1), - Trans(0, 101, 26, -1), + Trans(0, 33, 10, -1), + Trans(0, 34, 11, -1), + Trans(0, 35, 12, -1), + Trans(0, 36, 13, -1), + Trans(0, 37, 14, -1), + Trans(0, 39, 15, -1), + Trans(0, 40, 16, -1), + Trans(0, 41, 17, -1), + Trans(0, 42, 18, -1), + Trans(0, 43, 19, -1), + Trans(0, 44, 20, -1), + Trans(0, 45, 21, -1), + Trans(0, 46, 22, -1), + Trans(0, 47, 7, -1), + Trans(0, 51, 23, -1), + Trans(0, 79, 24, -1), + Trans(0, 93, 25, -1), + Trans(0, 102, 26, -1), Trans(1, 5, 4, -1), - Trans(1, 46, 42, -1), - Trans(1, 111, 2, -1), - Trans(2, 5, 3, 342), - Trans(2, 12, 3, 342), - Trans(2, 14, 3, 342), - Trans(2, 15, 3, 342), - Trans(2, 16, 3, 342), - Trans(2, 17, 3, 342), - Trans(2, 18, 3, 342), - Trans(2, 19, 3, 342), - Trans(2, 20, 3, 342), - Trans(2, 21, 3, 342), - Trans(2, 22, 3, 342), - Trans(2, 23, 3, 342), - Trans(2, 24, 3, 342), - Trans(2, 25, 3, 342), - Trans(2, 26, 3, 342), - Trans(2, 28, 3, 342), - Trans(2, 29, 3, 342), - Trans(2, 30, 3, 342), - Trans(2, 31, 3, 342), - Trans(2, 32, 3, 342), - Trans(2, 33, 3, 342), - Trans(2, 34, 3, 342), - Trans(2, 35, 3, 342), - Trans(2, 36, 3, 342), - Trans(2, 38, 3, 342), - Trans(2, 39, 3, 342), - Trans(2, 40, 3, 342), - Trans(2, 41, 3, 342), - Trans(2, 42, 3, 342), - Trans(2, 43, 3, 342), - Trans(2, 44, 3, 342), - Trans(2, 45, 3, 342), - Trans(2, 46, 3, 342), - Trans(2, 50, 3, 342), - Trans(2, 78, 3, 342), - Trans(2, 92, 3, 342), - Trans(2, 101, 3, 342), - Trans(4, 46, 27, 343), - Trans(4, 111, 3, 342), - Trans(5, 5, 54, -1), - Trans(5, 6, 55, -1), - Trans(5, 7, 55, -1), - Trans(5, 8, 55, -1), - Trans(5, 9, 55, -1), - Trans(5, 10, 55, -1), - Trans(5, 11, 55, -1), + Trans(1, 47, 42, -1), + Trans(1, 112, 2, -1), + Trans(2, 5, 3, 345), + Trans(2, 12, 3, 345), + Trans(2, 14, 3, 345), + Trans(2, 15, 3, 345), + Trans(2, 16, 3, 345), + Trans(2, 17, 3, 345), + Trans(2, 18, 3, 345), + Trans(2, 19, 3, 345), + Trans(2, 20, 3, 345), + Trans(2, 21, 3, 345), + Trans(2, 22, 3, 345), + Trans(2, 23, 3, 345), + Trans(2, 24, 3, 345), + Trans(2, 25, 3, 345), + Trans(2, 26, 3, 345), + Trans(2, 28, 3, 345), + Trans(2, 29, 3, 345), + Trans(2, 30, 3, 345), + Trans(2, 31, 3, 345), + Trans(2, 32, 3, 345), + Trans(2, 33, 3, 345), + Trans(2, 34, 3, 345), + Trans(2, 35, 3, 345), + Trans(2, 36, 3, 345), + Trans(2, 37, 3, 345), + Trans(2, 39, 3, 345), + Trans(2, 40, 3, 345), + Trans(2, 41, 3, 345), + Trans(2, 42, 3, 345), + Trans(2, 43, 3, 345), + Trans(2, 44, 3, 345), + Trans(2, 45, 3, 345), + Trans(2, 46, 3, 345), + Trans(2, 47, 3, 345), + Trans(2, 51, 3, 345), + Trans(2, 79, 3, 345), + Trans(2, 93, 3, 345), + Trans(2, 102, 3, 345), + Trans(4, 47, 27, 346), + Trans(4, 112, 3, 345), + Trans(5, 5, 63, -1), + Trans(5, 6, 64, -1), + Trans(5, 7, 64, -1), + Trans(5, 8, 64, -1), + Trans(5, 9, 64, -1), + Trans(5, 10, 64, -1), + Trans(5, 11, 64, -1), Trans(5, 18, 30, -1), Trans(5, 24, 30, -1), Trans(5, 25, 30, -1), Trans(5, 26, 30, -1), Trans(5, 27, 30, -1), - Trans(5, 37, 33, -1), - Trans(5, 38, 30, -1), - Trans(5, 40, 30, -1), - Trans(5, 52, 30, -1), - Trans(5, 69, 30, -1), - Trans(5, 75, 30, -1), - Trans(5, 82, 55, -1), - Trans(5, 85, 55, -1), - Trans(5, 87, 30, -1), - Trans(5, 110, 56, -1), - Trans(5, 111, 56, -1), - Trans(6, 5, 54, -1), - Trans(6, 6, 57, -1), - Trans(6, 7, 57, -1), - Trans(6, 8, 57, -1), - Trans(6, 9, 57, -1), - Trans(6, 10, 57, -1), - Trans(6, 11, 57, -1), + Trans(5, 38, 33, -1), + Trans(5, 39, 30, -1), + Trans(5, 41, 30, -1), + Trans(5, 53, 30, -1), + Trans(5, 70, 30, -1), + Trans(5, 76, 30, -1), + Trans(5, 83, 64, -1), + Trans(5, 86, 64, -1), + Trans(5, 88, 30, -1), + Trans(5, 111, 65, -1), + Trans(5, 112, 66, -1), + Trans(6, 5, 63, -1), + Trans(6, 6, 67, -1), + Trans(6, 7, 67, -1), + Trans(6, 8, 67, -1), + Trans(6, 9, 67, -1), + Trans(6, 10, 67, -1), + Trans(6, 11, 67, -1), Trans(6, 18, 30, -1), Trans(6, 24, 30, -1), Trans(6, 25, 30, -1), Trans(6, 26, 30, -1), Trans(6, 27, 30, -1), - Trans(6, 37, 33, -1), - Trans(6, 38, 30, -1), - Trans(6, 40, 30, -1), - Trans(6, 52, 30, -1), - Trans(6, 69, 30, -1), - Trans(6, 75, 30, -1), - Trans(6, 82, 57, -1), - Trans(6, 85, 57, -1), - Trans(6, 87, 30, -1), - Trans(6, 110, 58, -1), - Trans(6, 111, 58, -1), - Trans(7, 5, 54, -1), - Trans(7, 6, 59, -1), - Trans(7, 7, 59, -1), - Trans(7, 8, 59, -1), - Trans(7, 9, 59, -1), - Trans(7, 10, 59, -1), - Trans(7, 11, 59, -1), + Trans(6, 38, 33, -1), + Trans(6, 39, 30, -1), + Trans(6, 41, 30, -1), + Trans(6, 53, 30, -1), + Trans(6, 70, 30, -1), + Trans(6, 76, 30, -1), + Trans(6, 83, 67, -1), + Trans(6, 86, 67, -1), + Trans(6, 88, 30, -1), + Trans(6, 111, 68, -1), + Trans(6, 112, 69, -1), + Trans(7, 5, 63, -1), + Trans(7, 6, 70, -1), + Trans(7, 7, 70, -1), + Trans(7, 8, 70, -1), + Trans(7, 9, 70, -1), + Trans(7, 10, 70, -1), + Trans(7, 11, 70, -1), Trans(7, 18, 30, -1), Trans(7, 24, 30, -1), Trans(7, 25, 30, -1), Trans(7, 26, 30, -1), Trans(7, 27, 30, -1), - Trans(7, 37, 33, -1), - Trans(7, 38, 30, -1), - Trans(7, 40, 30, -1), - Trans(7, 52, 30, -1), - Trans(7, 69, 30, -1), - Trans(7, 75, 30, -1), - Trans(7, 82, 59, -1), - Trans(7, 85, 59, -1), - Trans(7, 87, 30, -1), - Trans(7, 110, 60, -1), - Trans(7, 111, 60, -1), - Trans(8, 5, 61, -1), - Trans(8, 6, 62, -1), - Trans(8, 7, 62, -1), - Trans(8, 8, 62, -1), - Trans(8, 9, 62, -1), - Trans(8, 10, 62, -1), - Trans(8, 11, 62, -1), + Trans(7, 38, 33, -1), + Trans(7, 39, 30, -1), + Trans(7, 41, 30, -1), + Trans(7, 53, 30, -1), + Trans(7, 70, 30, -1), + Trans(7, 76, 30, -1), + Trans(7, 83, 70, -1), + Trans(7, 86, 70, -1), + Trans(7, 88, 30, -1), + Trans(7, 111, 71, -1), + Trans(7, 112, 72, -1), + Trans(8, 5, 73, -1), + Trans(8, 6, 74, -1), + Trans(8, 7, 74, -1), + Trans(8, 8, 74, -1), + Trans(8, 9, 74, -1), + Trans(8, 10, 74, -1), + Trans(8, 11, 74, -1), Trans(8, 18, 30, -1), Trans(8, 24, 30, -1), Trans(8, 25, 30, -1), Trans(8, 26, 30, -1), Trans(8, 27, 30, -1), - Trans(8, 37, 33, -1), - Trans(8, 38, 63, -1), - Trans(8, 40, 30, -1), - Trans(8, 52, 30, -1), - Trans(8, 64, 31, -1), - Trans(8, 68, 36, -1), - Trans(8, 69, 30, -1), - Trans(8, 75, 30, -1), - Trans(8, 79, 31, -1), - Trans(8, 82, 62, -1), - Trans(8, 85, 62, -1), - Trans(8, 87, 30, -1), - Trans(8, 98, 30, -1), - Trans(8, 99, 42, -1), - Trans(8, 110, 64, -1), - Trans(8, 111, 65, -1), - Trans(9, 5, 66, -1), - Trans(9, 6, 67, -1), - Trans(9, 7, 67, -1), - Trans(9, 8, 67, -1), - Trans(9, 9, 67, -1), - Trans(9, 10, 67, -1), - Trans(9, 11, 67, -1), + Trans(8, 38, 33, -1), + Trans(8, 39, 75, -1), + Trans(8, 41, 30, -1), + Trans(8, 53, 30, -1), + Trans(8, 65, 31, -1), + Trans(8, 69, 36, -1), + Trans(8, 70, 30, -1), + Trans(8, 76, 30, -1), + Trans(8, 80, 31, -1), + Trans(8, 83, 74, -1), + Trans(8, 86, 74, -1), + Trans(8, 88, 30, -1), + Trans(8, 99, 30, -1), + Trans(8, 100, 42, -1), + Trans(8, 111, 76, -1), + Trans(8, 112, 77, -1), + Trans(9, 5, 78, -1), + Trans(9, 6, 79, -1), + Trans(9, 7, 79, -1), + Trans(9, 8, 79, -1), + Trans(9, 9, 79, -1), + Trans(9, 10, 79, -1), + Trans(9, 11, 79, -1), Trans(9, 18, 30, -1), Trans(9, 24, 30, -1), Trans(9, 25, 30, -1), Trans(9, 26, 30, -1), Trans(9, 27, 30, -1), - Trans(9, 35, 32, -1), - Trans(9, 37, 33, -1), - Trans(9, 38, 68, -1), - Trans(9, 40, 30, -1), - Trans(9, 42, 69, -1), - Trans(9, 44, 51, -1), - Trans(9, 52, 30, -1), - Trans(9, 56, 38, -1), - Trans(9, 69, 30, -1), - Trans(9, 75, 30, -1), - Trans(9, 80, 31, -1), - Trans(9, 82, 67, -1), - Trans(9, 85, 67, -1), - Trans(9, 87, 30, -1), - Trans(9, 89, 31, -1), - Trans(9, 110, 70, -1), - Trans(9, 111, 71, -1), - Trans(10, 5, 54, -1), - Trans(10, 6, 72, -1), - Trans(10, 7, 72, -1), - Trans(10, 8, 72, -1), - Trans(10, 9, 72, -1), - Trans(10, 10, 72, -1), - Trans(10, 11, 72, -1), + Trans(9, 36, 32, -1), + Trans(9, 38, 33, -1), + Trans(9, 39, 80, -1), + Trans(9, 41, 30, -1), + Trans(9, 42, 60, -1), + Trans(9, 43, 81, -1), + Trans(9, 45, 52, -1), + Trans(9, 53, 30, -1), + Trans(9, 57, 38, -1), + Trans(9, 70, 30, -1), + Trans(9, 76, 30, -1), + Trans(9, 81, 31, -1), + Trans(9, 83, 79, -1), + Trans(9, 86, 79, -1), + Trans(9, 88, 30, -1), + Trans(9, 90, 31, -1), + Trans(9, 111, 82, -1), + Trans(9, 112, 83, -1), + Trans(10, 5, 63, -1), + Trans(10, 6, 84, -1), + Trans(10, 7, 84, -1), + Trans(10, 8, 84, -1), + Trans(10, 9, 84, -1), + Trans(10, 10, 84, -1), + Trans(10, 11, 84, -1), Trans(10, 18, 30, -1), Trans(10, 24, 30, -1), Trans(10, 25, 30, -1), Trans(10, 26, 30, -1), Trans(10, 27, 30, -1), - Trans(10, 37, 33, -1), - Trans(10, 38, 30, -1), - Trans(10, 40, 30, -1), - Trans(10, 52, 30, -1), - Trans(10, 69, 30, -1), - Trans(10, 75, 30, -1), - Trans(10, 82, 72, -1), - Trans(10, 85, 72, -1), - Trans(10, 87, 30, -1), - Trans(10, 110, 73, -1), - Trans(10, 111, 73, -1), - Trans(11, 5, 112, -1), - Trans(11, 111, 113, -1), - Trans(12, 5, 54, -1), - Trans(12, 6, 74, -1), - Trans(12, 7, 74, -1), - Trans(12, 8, 74, -1), - Trans(12, 9, 74, -1), - Trans(12, 10, 74, -1), - Trans(12, 11, 74, -1), + Trans(10, 38, 33, -1), + Trans(10, 39, 30, -1), + Trans(10, 41, 30, -1), + Trans(10, 53, 30, -1), + Trans(10, 70, 30, -1), + Trans(10, 76, 30, -1), + Trans(10, 83, 84, -1), + Trans(10, 86, 84, -1), + Trans(10, 88, 30, -1), + Trans(10, 111, 85, -1), + Trans(10, 112, 86, -1), + Trans(11, 5, 123, -1), + Trans(11, 112, 124, -1), + Trans(12, 5, 63, -1), + Trans(12, 6, 87, -1), + Trans(12, 7, 87, -1), + Trans(12, 8, 87, -1), + Trans(12, 9, 87, -1), + Trans(12, 10, 87, -1), + Trans(12, 11, 87, -1), Trans(12, 18, 30, -1), Trans(12, 24, 30, -1), Trans(12, 25, 30, -1), Trans(12, 26, 30, -1), Trans(12, 27, 30, -1), - Trans(12, 37, 33, -1), - Trans(12, 38, 30, -1), - Trans(12, 40, 30, -1), - Trans(12, 52, 30, -1), - Trans(12, 69, 30, -1), - Trans(12, 75, 30, -1), - Trans(12, 82, 74, -1), - Trans(12, 85, 74, -1), - Trans(12, 87, 30, -1), - Trans(12, 110, 75, -1), - Trans(12, 111, 75, -1), - Trans(13, 5, 109, -1), - Trans(13, 40, 101, -1), - Trans(14, 5, 54, -1), - Trans(14, 6, 76, -1), - Trans(14, 7, 76, -1), - Trans(14, 8, 76, -1), - Trans(14, 9, 76, -1), - Trans(14, 10, 76, -1), - Trans(14, 11, 76, -1), + Trans(12, 38, 33, -1), + Trans(12, 39, 30, -1), + Trans(12, 41, 30, -1), + Trans(12, 53, 30, -1), + Trans(12, 70, 30, -1), + Trans(12, 76, 30, -1), + Trans(12, 83, 87, -1), + Trans(12, 86, 87, -1), + Trans(12, 88, 30, -1), + Trans(12, 111, 88, -1), + Trans(12, 112, 89, -1), + Trans(13, 5, 119, -1), + Trans(13, 41, 117, -1), + Trans(14, 5, 63, -1), + Trans(14, 6, 90, -1), + Trans(14, 7, 90, -1), + Trans(14, 8, 90, -1), + Trans(14, 9, 90, -1), + Trans(14, 10, 90, -1), + Trans(14, 11, 90, -1), Trans(14, 18, 30, -1), Trans(14, 24, 30, -1), Trans(14, 25, 30, -1), Trans(14, 26, 30, -1), Trans(14, 27, 30, -1), - Trans(14, 37, 33, -1), - Trans(14, 38, 30, -1), - Trans(14, 40, 30, -1), - Trans(14, 52, 30, -1), - Trans(14, 69, 30, -1), - Trans(14, 75, 30, -1), - Trans(14, 82, 76, -1), - Trans(14, 85, 76, -1), - Trans(14, 87, 30, -1), - Trans(14, 110, 77, -1), - Trans(14, 111, 77, -1), - Trans(15, 5, 78, -1), - Trans(15, 6, 79, -1), - Trans(15, 7, 79, -1), - Trans(15, 8, 79, -1), - Trans(15, 9, 79, -1), - Trans(15, 10, 79, -1), - Trans(15, 11, 79, -1), + Trans(14, 38, 33, -1), + Trans(14, 39, 30, -1), + Trans(14, 41, 30, -1), + Trans(14, 53, 30, -1), + Trans(14, 70, 30, -1), + Trans(14, 76, 30, -1), + Trans(14, 83, 90, -1), + Trans(14, 86, 90, -1), + Trans(14, 88, 30, -1), + Trans(14, 111, 91, -1), + Trans(14, 112, 92, -1), + Trans(15, 5, 93, -1), + Trans(15, 6, 94, -1), + Trans(15, 7, 94, -1), + Trans(15, 8, 94, -1), + Trans(15, 9, 94, -1), + Trans(15, 10, 94, -1), + Trans(15, 11, 94, -1), Trans(15, 18, 30, -1), Trans(15, 24, 30, -1), Trans(15, 25, 30, -1), Trans(15, 26, 30, -1), Trans(15, 27, 30, -1), - Trans(15, 29, 31, -1), - Trans(15, 35, 32, -1), - Trans(15, 37, 33, -1), - Trans(15, 38, 80, -1), - Trans(15, 40, 30, -1), - Trans(15, 42, 81, -1), - Trans(15, 47, 36, -1), - Trans(15, 48, 37, -1), - Trans(15, 49, 31, -1), - Trans(15, 52, 30, -1), - Trans(15, 56, 38, -1), - Trans(15, 59, 31, -1), - Trans(15, 63, 36, -1), - Trans(15, 64, 31, -1), + Trans(15, 30, 31, -1), + Trans(15, 36, 32, -1), + Trans(15, 38, 33, -1), + Trans(15, 39, 95, -1), + Trans(15, 41, 30, -1), + Trans(15, 43, 96, -1), + Trans(15, 48, 36, -1), + Trans(15, 49, 37, -1), + Trans(15, 50, 31, -1), + Trans(15, 53, 30, -1), + Trans(15, 57, 38, -1), + Trans(15, 60, 31, -1), + Trans(15, 64, 36, -1), Trans(15, 65, 31, -1), - Trans(15, 68, 36, -1), - Trans(15, 69, 30, -1), - Trans(15, 70, 40, -1), - Trans(15, 72, 36, -1), - Trans(15, 75, 30, -1), - Trans(15, 76, 31, -1), - Trans(15, 79, 31, -1), + Trans(15, 66, 31, -1), + Trans(15, 69, 36, -1), + Trans(15, 70, 30, -1), + Trans(15, 71, 40, -1), + Trans(15, 73, 36, -1), + Trans(15, 76, 30, -1), + Trans(15, 77, 31, -1), Trans(15, 80, 31, -1), - Trans(15, 82, 79, -1), - Trans(15, 83, 31, -1), - Trans(15, 85, 79, -1), - Trans(15, 87, 30, -1), - Trans(15, 98, 30, -1), - Trans(15, 99, 42, -1), - Trans(15, 103, 31, -1), - Trans(15, 105, 31, -1), - Trans(15, 108, 31, -1), + Trans(15, 81, 31, -1), + Trans(15, 83, 94, -1), + Trans(15, 84, 31, -1), + Trans(15, 86, 94, -1), + Trans(15, 88, 30, -1), + Trans(15, 99, 30, -1), + Trans(15, 100, 42, -1), + Trans(15, 104, 31, -1), + Trans(15, 106, 31, -1), Trans(15, 109, 31, -1), - Trans(15, 110, 82, -1), - Trans(15, 111, 82, -1), - Trans(16, 5, 54, -1), - Trans(16, 6, 83, -1), - Trans(16, 7, 83, -1), - Trans(16, 8, 83, -1), - Trans(16, 9, 83, -1), - Trans(16, 10, 83, -1), - Trans(16, 11, 83, -1), + Trans(15, 110, 31, -1), + Trans(15, 111, 97, -1), + Trans(15, 112, 98, -1), + Trans(16, 5, 63, -1), + Trans(16, 6, 99, -1), + Trans(16, 7, 99, -1), + Trans(16, 8, 99, -1), + Trans(16, 9, 99, -1), + Trans(16, 10, 99, -1), + Trans(16, 11, 99, -1), Trans(16, 18, 30, -1), Trans(16, 24, 30, -1), Trans(16, 25, 30, -1), Trans(16, 26, 30, -1), Trans(16, 27, 30, -1), - Trans(16, 37, 33, -1), - Trans(16, 38, 30, -1), - Trans(16, 40, 30, -1), - Trans(16, 52, 30, -1), - Trans(16, 69, 30, -1), - Trans(16, 75, 30, -1), - Trans(16, 82, 83, -1), - Trans(16, 85, 83, -1), - Trans(16, 87, 30, -1), - Trans(16, 110, 84, -1), - Trans(16, 111, 84, -1), - Trans(17, 5, 85, -1), - Trans(17, 6, 86, -1), - Trans(17, 7, 86, -1), - Trans(17, 8, 86, -1), - Trans(17, 9, 86, -1), - Trans(17, 10, 86, -1), - Trans(17, 11, 86, -1), + Trans(16, 38, 33, -1), + Trans(16, 39, 30, -1), + Trans(16, 41, 30, -1), + Trans(16, 53, 30, -1), + Trans(16, 70, 30, -1), + Trans(16, 76, 30, -1), + Trans(16, 83, 99, -1), + Trans(16, 86, 99, -1), + Trans(16, 88, 30, -1), + Trans(16, 111, 100, -1), + Trans(16, 112, 101, -1), + Trans(17, 5, 102, -1), + Trans(17, 6, 103, -1), + Trans(17, 7, 103, -1), + Trans(17, 8, 103, -1), + Trans(17, 9, 103, -1), + Trans(17, 10, 103, -1), + Trans(17, 11, 103, -1), Trans(17, 18, 30, -1), Trans(17, 24, 30, -1), Trans(17, 25, 30, -1), Trans(17, 26, 30, -1), Trans(17, 27, 30, -1), - Trans(17, 35, 32, -1), - Trans(17, 37, 33, -1), - Trans(17, 38, 87, -1), - Trans(17, 40, 30, -1), - Trans(17, 44, 59, -1), - Trans(17, 52, 30, -1), - Trans(17, 69, 30, -1), - Trans(17, 75, 30, -1), - Trans(17, 82, 86, -1), - Trans(17, 85, 86, -1), - Trans(17, 87, 30, -1), - Trans(17, 110, 88, -1), - Trans(17, 111, 89, -1), - Trans(18, 5, 103, -1), - Trans(18, 30, 104, -1), - Trans(18, 34, 30, -1), - Trans(18, 38, 105, -1), - Trans(18, 39, 30, -1), - Trans(18, 42, 106, -1), - Trans(18, 44, 107, -1), - Trans(18, 45, 108, -1), - Trans(18, 78, 30, -1), - Trans(19, 5, 44, -1), + Trans(17, 36, 32, -1), + Trans(17, 38, 33, -1), + Trans(17, 39, 104, -1), + Trans(17, 41, 30, -1), + Trans(17, 45, 70, -1), + Trans(17, 53, 30, -1), + Trans(17, 70, 30, -1), + Trans(17, 76, 30, -1), + Trans(17, 83, 103, -1), + Trans(17, 86, 103, -1), + Trans(17, 88, 30, -1), + Trans(17, 111, 105, -1), + Trans(17, 112, 106, -1), + Trans(18, 5, 55, -1), + Trans(18, 12, 30, -1), + Trans(18, 14, 30, -1), + Trans(18, 15, 30, -1), + Trans(18, 16, 30, -1), + Trans(18, 17, 30, -1), + Trans(18, 18, 30, -1), + Trans(18, 19, 30, -1), + Trans(18, 20, 30, -1), + Trans(18, 21, 30, -1), + Trans(18, 22, 30, -1), + Trans(18, 23, 30, -1), + Trans(18, 24, 30, -1), + Trans(18, 25, 30, -1), + Trans(18, 26, 30, -1), + Trans(18, 29, 56, -1), + Trans(18, 30, 46, -1), + Trans(18, 31, 57, -1), + Trans(18, 32, 30, -1), + Trans(18, 33, 30, -1), + Trans(18, 34, 31, -1), + Trans(18, 35, 30, -1), + Trans(18, 36, 37, -1), + Trans(18, 37, 30, -1), + Trans(18, 39, 58, -1), + Trans(18, 40, 30, -1), + Trans(18, 41, 59, -1), + Trans(18, 42, 60, -1), + Trans(18, 43, 61, -1), + Trans(18, 44, 51, -1), + Trans(18, 45, 52, -1), + Trans(18, 46, 62, -1), + Trans(18, 47, 30, -1), + Trans(18, 51, 40, -1), + Trans(18, 79, 30, -1), + Trans(18, 93, 30, -1), + Trans(18, 102, 54, -1), + Trans(19, 5, 45, -1), Trans(19, 12, 30, -1), Trans(19, 14, 30, -1), Trans(19, 16, 30, -1), @@ -11646,42 +12374,42 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(19, 24, 30, -1), Trans(19, 25, 30, -1), Trans(19, 26, 30, -1), - Trans(19, 29, 45, -1), Trans(19, 30, 46, -1), - Trans(19, 31, 30, -1), + Trans(19, 31, 47, -1), Trans(19, 32, 30, -1), - Trans(19, 35, 32, -1), - Trans(19, 38, 47, -1), - Trans(19, 41, 48, -1), + Trans(19, 33, 30, -1), + Trans(19, 36, 32, -1), + Trans(19, 39, 48, -1), Trans(19, 42, 49, -1), Trans(19, 43, 50, -1), Trans(19, 44, 51, -1), - Trans(19, 45, 47, -1), - Trans(19, 46, 30, -1), - Trans(19, 47, 36, -1), - Trans(19, 48, 37, -1), - Trans(19, 49, 31, -1), - Trans(19, 50, 40, -1), - Trans(19, 57, 52, -1), - Trans(19, 59, 31, -1), - Trans(19, 60, 39, -1), - Trans(19, 63, 36, -1), - Trans(19, 64, 31, -1), + Trans(19, 45, 52, -1), + Trans(19, 46, 48, -1), + Trans(19, 47, 30, -1), + Trans(19, 48, 36, -1), + Trans(19, 49, 37, -1), + Trans(19, 50, 31, -1), + Trans(19, 51, 40, -1), + Trans(19, 58, 53, -1), + Trans(19, 60, 31, -1), + Trans(19, 61, 39, -1), + Trans(19, 64, 36, -1), Trans(19, 65, 31, -1), - Trans(19, 69, 30, -1), - Trans(19, 70, 40, -1), - Trans(19, 72, 36, -1), - Trans(19, 76, 31, -1), - Trans(19, 79, 31, -1), + Trans(19, 66, 31, -1), + Trans(19, 70, 30, -1), + Trans(19, 71, 40, -1), + Trans(19, 73, 36, -1), + Trans(19, 77, 31, -1), Trans(19, 80, 31, -1), - Trans(19, 83, 31, -1), - Trans(19, 92, 30, -1), - Trans(19, 101, 53, -1), - Trans(19, 103, 31, -1), - Trans(19, 105, 31, -1), - Trans(19, 108, 31, -1), + Trans(19, 81, 31, -1), + Trans(19, 84, 31, -1), + Trans(19, 93, 30, -1), + Trans(19, 102, 54, -1), + Trans(19, 104, 31, -1), + Trans(19, 106, 31, -1), Trans(19, 109, 31, -1), - Trans(20, 5, 95, -1), + Trans(19, 110, 31, -1), + Trans(20, 5, 114, -1), Trans(20, 12, 30, -1), Trans(20, 14, 30, -1), Trans(20, 15, 30, -1), @@ -11696,28 +12424,28 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(20, 24, 30, -1), Trans(20, 25, 30, -1), Trans(20, 26, 30, -1), - Trans(20, 29, 45, -1), Trans(20, 30, 46, -1), - Trans(20, 31, 30, -1), + Trans(20, 31, 47, -1), Trans(20, 32, 30, -1), - Trans(20, 33, 31, -1), - Trans(20, 34, 30, -1), - Trans(20, 35, 37, -1), - Trans(20, 38, 96, -1), - Trans(20, 39, 30, -1), - Trans(20, 40, 97, -1), - Trans(20, 41, 48, -1), - Trans(20, 42, 98, -1), - Trans(20, 43, 50, -1), + Trans(20, 33, 30, -1), + Trans(20, 34, 31, -1), + Trans(20, 35, 30, -1), + Trans(20, 36, 37, -1), + Trans(20, 39, 58, -1), + Trans(20, 40, 30, -1), + Trans(20, 41, 59, -1), + Trans(20, 42, 49, -1), + Trans(20, 43, 61, -1), Trans(20, 44, 51, -1), - Trans(20, 45, 47, -1), - Trans(20, 46, 30, -1), - Trans(20, 50, 40, -1), - Trans(20, 92, 30, -1), - Trans(20, 101, 53, -1), - Trans(21, 5, 99, -1), + Trans(20, 45, 52, -1), + Trans(20, 46, 48, -1), + Trans(20, 47, 30, -1), + Trans(20, 51, 40, -1), + Trans(20, 93, 30, -1), + Trans(20, 102, 54, -1), + Trans(21, 5, 115, -1), Trans(21, 12, 30, -1), - Trans(21, 13, 100, -1), + Trans(21, 13, 116, -1), Trans(21, 14, 30, -1), Trans(21, 16, 30, -1), Trans(21, 17, 30, -1), @@ -11730,22 +12458,22 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(21, 24, 30, -1), Trans(21, 25, 30, -1), Trans(21, 26, 30, -1), - Trans(21, 29, 45, -1), Trans(21, 30, 46, -1), - Trans(21, 31, 30, -1), + Trans(21, 31, 47, -1), Trans(21, 32, 30, -1), - Trans(21, 38, 96, -1), - Trans(21, 40, 101, -1), - Trans(21, 41, 48, -1), - Trans(21, 42, 98, -1), - Trans(21, 43, 50, -1), - Trans(21, 44, 102, -1), - Trans(21, 45, 47, -1), - Trans(21, 46, 30, -1), - Trans(21, 50, 40, -1), - Trans(21, 92, 30, -1), - Trans(21, 101, 53, -1), - Trans(22, 0, 27, 343), + Trans(21, 33, 30, -1), + Trans(21, 39, 58, -1), + Trans(21, 41, 117, -1), + Trans(21, 42, 49, -1), + Trans(21, 43, 61, -1), + Trans(21, 44, 51, -1), + Trans(21, 45, 118, -1), + Trans(21, 46, 48, -1), + Trans(21, 47, 30, -1), + Trans(21, 51, 40, -1), + Trans(21, 93, 30, -1), + Trans(21, 102, 54, -1), + Trans(22, 0, 27, 346), Trans(22, 5, 28, -1), Trans(22, 6, 29, -1), Trans(22, 7, 29, -1), @@ -11758,2984 +12486,4091 @@ pub const LOOKAHEAD_AUTOMATA: &[LookaheadDFA; 616] = &[ Trans(22, 25, 30, -1), Trans(22, 26, 30, -1), Trans(22, 27, 30, -1), - Trans(22, 29, 31, -1), - Trans(22, 35, 32, -1), - Trans(22, 37, 33, -1), - Trans(22, 38, 34, -1), - Trans(22, 40, 30, -1), - Trans(22, 42, 35, -1), - Trans(22, 47, 36, -1), - Trans(22, 48, 37, -1), - Trans(22, 49, 31, -1), - Trans(22, 52, 30, -1), - Trans(22, 56, 38, -1), - Trans(22, 58, 37, -1), - Trans(22, 59, 31, -1), - Trans(22, 60, 39, -1), - Trans(22, 63, 36, -1), - Trans(22, 64, 31, -1), + Trans(22, 30, 31, -1), + Trans(22, 36, 32, -1), + Trans(22, 38, 33, -1), + Trans(22, 39, 34, -1), + Trans(22, 41, 30, -1), + Trans(22, 43, 35, -1), + Trans(22, 48, 36, -1), + Trans(22, 49, 37, -1), + Trans(22, 50, 31, -1), + Trans(22, 53, 30, -1), + Trans(22, 57, 38, -1), + Trans(22, 59, 37, -1), + Trans(22, 60, 31, -1), + Trans(22, 61, 39, -1), + Trans(22, 64, 36, -1), Trans(22, 65, 31, -1), - Trans(22, 68, 36, -1), - Trans(22, 69, 30, -1), - Trans(22, 70, 40, -1), - Trans(22, 71, 37, -1), - Trans(22, 72, 36, -1), - Trans(22, 75, 30, -1), - Trans(22, 76, 31, -1), + Trans(22, 66, 31, -1), + Trans(22, 69, 36, -1), + Trans(22, 70, 30, -1), + Trans(22, 71, 40, -1), + Trans(22, 72, 37, -1), + Trans(22, 73, 36, -1), + Trans(22, 76, 30, -1), Trans(22, 77, 31, -1), - Trans(22, 79, 31, -1), + Trans(22, 78, 31, -1), Trans(22, 80, 31, -1), - Trans(22, 82, 29, -1), - Trans(22, 83, 31, -1), + Trans(22, 81, 31, -1), + Trans(22, 83, 29, -1), Trans(22, 84, 31, -1), - Trans(22, 85, 29, -1), - Trans(22, 87, 30, -1), - Trans(22, 88, 31, -1), - Trans(22, 90, 41, -1), - Trans(22, 98, 30, -1), - Trans(22, 99, 42, -1), - Trans(22, 103, 31, -1), - Trans(22, 105, 31, -1), - Trans(22, 108, 31, -1), + Trans(22, 85, 31, -1), + Trans(22, 86, 29, -1), + Trans(22, 88, 30, -1), + Trans(22, 89, 31, -1), + Trans(22, 91, 41, -1), + Trans(22, 99, 30, -1), + Trans(22, 100, 42, -1), + Trans(22, 104, 31, -1), + Trans(22, 106, 31, -1), Trans(22, 109, 31, -1), - Trans(22, 110, 43, -1), + Trans(22, 110, 31, -1), Trans(22, 111, 43, -1), - Trans(23, 5, 110, -1), - Trans(23, 110, 111, -1), - Trans(23, 111, 111, -1), - Trans(24, 5, 54, -1), - Trans(24, 6, 90, -1), - Trans(24, 7, 90, -1), - Trans(24, 8, 90, -1), - Trans(24, 9, 90, -1), - Trans(24, 10, 90, -1), - Trans(24, 11, 90, -1), + Trans(22, 112, 44, -1), + Trans(23, 5, 120, -1), + Trans(23, 111, 121, -1), + Trans(23, 112, 122, -1), + Trans(24, 5, 63, -1), + Trans(24, 6, 107, -1), + Trans(24, 7, 107, -1), + Trans(24, 8, 107, -1), + Trans(24, 9, 107, -1), + Trans(24, 10, 107, -1), + Trans(24, 11, 107, -1), Trans(24, 18, 30, -1), Trans(24, 24, 30, -1), Trans(24, 25, 30, -1), Trans(24, 26, 30, -1), Trans(24, 27, 30, -1), - Trans(24, 37, 33, -1), - Trans(24, 38, 30, -1), - Trans(24, 40, 30, -1), - Trans(24, 52, 30, -1), - Trans(24, 69, 30, -1), - Trans(24, 75, 30, -1), - Trans(24, 82, 90, -1), - Trans(24, 85, 90, -1), - Trans(24, 87, 30, -1), - Trans(24, 110, 91, -1), - Trans(24, 111, 91, -1), - Trans(25, 5, 54, -1), - Trans(25, 6, 92, -1), - Trans(25, 7, 92, -1), - Trans(25, 8, 92, -1), - Trans(25, 9, 92, -1), - Trans(25, 10, 92, -1), - Trans(25, 11, 92, -1), + Trans(24, 38, 33, -1), + Trans(24, 39, 30, -1), + Trans(24, 41, 30, -1), + Trans(24, 53, 30, -1), + Trans(24, 70, 30, -1), + Trans(24, 76, 30, -1), + Trans(24, 83, 107, -1), + Trans(24, 86, 107, -1), + Trans(24, 88, 30, -1), + Trans(24, 111, 108, -1), + Trans(24, 112, 109, -1), + Trans(25, 5, 63, -1), + Trans(25, 6, 110, -1), + Trans(25, 7, 110, -1), + Trans(25, 8, 110, -1), + Trans(25, 9, 110, -1), + Trans(25, 10, 110, -1), + Trans(25, 11, 110, -1), Trans(25, 18, 30, -1), Trans(25, 24, 30, -1), Trans(25, 25, 30, -1), Trans(25, 26, 30, -1), Trans(25, 27, 30, -1), - Trans(25, 37, 33, -1), - Trans(25, 38, 30, -1), - Trans(25, 40, 30, -1), - Trans(25, 52, 30, -1), - Trans(25, 69, 30, -1), - Trans(25, 75, 30, -1), - Trans(25, 82, 92, -1), - Trans(25, 85, 92, -1), - Trans(25, 87, 30, -1), - Trans(25, 110, 93, -1), - Trans(25, 111, 93, -1), - Trans(26, 5, 94, -1), - Trans(26, 6, 55, -1), - Trans(26, 7, 55, -1), - Trans(26, 8, 55, -1), - Trans(26, 9, 55, -1), - Trans(26, 10, 55, -1), - Trans(26, 11, 55, -1), + Trans(25, 38, 33, -1), + Trans(25, 39, 30, -1), + Trans(25, 41, 30, -1), + Trans(25, 53, 30, -1), + Trans(25, 70, 30, -1), + Trans(25, 76, 30, -1), + Trans(25, 83, 110, -1), + Trans(25, 86, 110, -1), + Trans(25, 88, 30, -1), + Trans(25, 111, 111, -1), + Trans(25, 112, 112, -1), + Trans(26, 5, 113, -1), + Trans(26, 6, 64, -1), + Trans(26, 7, 64, -1), + Trans(26, 8, 64, -1), + Trans(26, 9, 64, -1), + Trans(26, 10, 64, -1), + Trans(26, 11, 64, -1), Trans(26, 15, 30, -1), Trans(26, 18, 30, -1), Trans(26, 24, 30, -1), Trans(26, 25, 30, -1), Trans(26, 26, 30, -1), Trans(26, 27, 30, -1), - Trans(26, 37, 33, -1), - Trans(26, 38, 30, -1), - Trans(26, 40, 30, -1), - Trans(26, 52, 30, -1), - Trans(26, 69, 30, -1), - Trans(26, 75, 30, -1), - Trans(26, 82, 55, -1), - Trans(26, 85, 55, -1), - Trans(26, 87, 30, -1), - Trans(26, 110, 56, -1), - Trans(26, 111, 56, -1), - Trans(28, 0, 27, 343), - Trans(28, 6, 27, 343), - Trans(28, 7, 27, 343), - Trans(28, 8, 27, 343), - Trans(28, 9, 27, 343), - Trans(28, 10, 27, 343), - Trans(28, 11, 27, 343), - Trans(28, 18, 27, 343), - Trans(28, 24, 27, 343), - Trans(28, 25, 27, 343), - Trans(28, 26, 27, 343), - Trans(28, 27, 27, 343), - Trans(28, 29, 27, 343), - Trans(28, 35, 27, 343), - Trans(28, 37, 27, 343), - Trans(28, 38, 27, 343), - Trans(28, 40, 27, 343), - Trans(28, 42, 27, 343), - Trans(28, 47, 27, 343), - Trans(28, 48, 27, 343), - Trans(28, 49, 27, 343), - Trans(28, 52, 27, 343), - Trans(28, 56, 27, 343), - Trans(28, 58, 27, 343), - Trans(28, 59, 27, 343), - Trans(28, 60, 27, 343), - Trans(28, 63, 27, 343), - Trans(28, 64, 27, 343), - Trans(28, 65, 27, 343), - Trans(28, 68, 27, 343), - Trans(28, 69, 27, 343), - Trans(28, 70, 27, 343), - Trans(28, 71, 27, 343), - Trans(28, 72, 27, 343), - Trans(28, 75, 27, 343), - Trans(28, 76, 27, 343), - Trans(28, 77, 27, 343), - Trans(28, 79, 27, 343), - Trans(28, 80, 27, 343), - Trans(28, 82, 27, 343), - Trans(28, 83, 27, 343), - Trans(28, 84, 27, 343), - Trans(28, 85, 27, 343), - Trans(28, 87, 27, 343), - Trans(28, 88, 27, 343), - Trans(28, 90, 27, 343), - Trans(28, 98, 27, 343), - Trans(28, 99, 27, 343), - Trans(28, 103, 27, 343), - Trans(28, 105, 27, 343), - Trans(28, 108, 27, 343), - Trans(28, 109, 27, 343), - Trans(28, 110, 27, 343), - Trans(28, 111, 27, 343), - Trans(29, 5, 27, 343), - Trans(29, 16, 27, 343), - Trans(29, 17, 27, 343), - Trans(29, 18, 27, 343), - Trans(29, 19, 27, 343), - Trans(29, 20, 27, 343), - Trans(29, 21, 27, 343), - Trans(29, 22, 27, 343), - Trans(29, 23, 27, 343), - Trans(29, 24, 27, 343), - Trans(29, 25, 27, 343), - Trans(29, 26, 27, 343), - Trans(29, 29, 27, 343), - Trans(29, 30, 27, 343), - Trans(29, 46, 27, 343), - Trans(29, 50, 27, 343), - Trans(30, 5, 27, 343), - Trans(30, 6, 27, 343), - Trans(30, 7, 27, 343), - Trans(30, 8, 27, 343), - Trans(30, 9, 27, 343), - Trans(30, 10, 27, 343), - Trans(30, 11, 27, 343), - Trans(30, 18, 27, 343), - Trans(30, 24, 27, 343), - Trans(30, 25, 27, 343), - Trans(30, 26, 27, 343), - Trans(30, 27, 27, 343), - Trans(30, 37, 27, 343), - Trans(30, 38, 27, 343), - Trans(30, 40, 27, 343), - Trans(30, 52, 27, 343), - Trans(30, 69, 27, 343), - Trans(30, 75, 27, 343), - Trans(30, 82, 27, 343), - Trans(30, 85, 27, 343), - Trans(30, 87, 27, 343), - Trans(30, 110, 27, 343), - Trans(30, 111, 27, 343), - Trans(31, 5, 27, 343), - Trans(31, 111, 27, 343), - Trans(32, 5, 27, 343), - Trans(32, 39, 27, 343), - Trans(33, 5, 27, 343), - Trans(33, 6, 27, 343), - Trans(33, 7, 27, 343), - Trans(33, 8, 27, 343), - Trans(33, 9, 27, 343), - Trans(33, 10, 27, 343), - Trans(33, 11, 27, 343), - Trans(33, 18, 27, 343), - Trans(33, 24, 27, 343), - Trans(33, 25, 27, 343), - Trans(33, 26, 27, 343), - Trans(33, 27, 27, 343), - Trans(33, 37, 27, 343), - Trans(33, 38, 27, 343), - Trans(33, 40, 27, 343), - Trans(33, 52, 27, 343), - Trans(33, 56, 27, 343), - Trans(33, 69, 27, 343), - Trans(33, 75, 27, 343), - Trans(33, 82, 27, 343), - Trans(33, 85, 27, 343), - Trans(33, 87, 27, 343), - Trans(33, 110, 27, 343), - Trans(33, 111, 27, 343), - Trans(34, 5, 27, 343), - Trans(34, 6, 27, 343), - Trans(34, 7, 27, 343), - Trans(34, 8, 27, 343), - Trans(34, 9, 27, 343), - Trans(34, 10, 27, 343), - Trans(34, 11, 27, 343), - Trans(34, 18, 27, 343), - Trans(34, 24, 27, 343), - Trans(34, 25, 27, 343), - Trans(34, 26, 27, 343), - Trans(34, 27, 27, 343), - Trans(34, 29, 27, 343), - Trans(34, 35, 27, 343), - Trans(34, 37, 27, 343), - Trans(34, 38, 27, 343), - Trans(34, 40, 27, 343), - Trans(34, 42, 27, 343), - Trans(34, 47, 27, 343), - Trans(34, 48, 27, 343), - Trans(34, 49, 27, 343), - Trans(34, 52, 27, 343), - Trans(34, 58, 27, 343), - Trans(34, 59, 27, 343), - Trans(34, 60, 27, 343), - Trans(34, 63, 27, 343), - Trans(34, 64, 27, 343), - Trans(34, 65, 27, 343), - Trans(34, 69, 27, 343), - Trans(34, 70, 27, 343), - Trans(34, 71, 27, 343), - Trans(34, 72, 27, 343), - Trans(34, 75, 27, 343), - Trans(34, 76, 27, 343), - Trans(34, 77, 27, 343), - Trans(34, 79, 27, 343), - Trans(34, 80, 27, 343), - Trans(34, 82, 27, 343), - Trans(34, 83, 27, 343), - Trans(34, 84, 27, 343), - Trans(34, 85, 27, 343), - Trans(34, 87, 27, 343), - Trans(34, 88, 27, 343), - Trans(34, 90, 27, 343), - Trans(34, 103, 27, 343), - Trans(34, 105, 27, 343), - Trans(34, 108, 27, 343), - Trans(34, 109, 27, 343), - Trans(34, 110, 27, 343), - Trans(34, 111, 27, 343), - Trans(35, 0, 27, 343), - Trans(35, 5, 27, 343), - Trans(35, 6, 27, 343), - Trans(35, 7, 27, 343), - Trans(35, 8, 27, 343), - Trans(35, 9, 27, 343), - Trans(35, 10, 27, 343), - Trans(35, 11, 27, 343), - Trans(35, 18, 27, 343), - Trans(35, 24, 27, 343), - Trans(35, 25, 27, 343), - Trans(35, 26, 27, 343), - Trans(35, 27, 27, 343), - Trans(35, 29, 27, 343), - Trans(35, 35, 27, 343), - Trans(35, 37, 27, 343), - Trans(35, 38, 27, 343), - Trans(35, 40, 27, 343), - Trans(35, 42, 27, 343), - Trans(35, 47, 27, 343), - Trans(35, 48, 27, 343), - Trans(35, 49, 27, 343), - Trans(35, 52, 27, 343), - Trans(35, 56, 27, 343), - Trans(35, 57, 27, 343), - Trans(35, 58, 27, 343), - Trans(35, 59, 27, 343), - Trans(35, 60, 27, 343), - Trans(35, 63, 27, 343), - Trans(35, 64, 27, 343), - Trans(35, 65, 27, 343), - Trans(35, 68, 27, 343), - Trans(35, 69, 27, 343), - Trans(35, 70, 27, 343), - Trans(35, 71, 27, 343), - Trans(35, 72, 27, 343), - Trans(35, 75, 27, 343), - Trans(35, 76, 27, 343), - Trans(35, 77, 27, 343), - Trans(35, 79, 27, 343), - Trans(35, 80, 27, 343), - Trans(35, 82, 27, 343), - Trans(35, 83, 27, 343), - Trans(35, 84, 27, 343), - Trans(35, 85, 27, 343), - Trans(35, 87, 27, 343), - Trans(35, 88, 27, 343), - Trans(35, 90, 27, 343), - Trans(35, 98, 27, 343), - Trans(35, 99, 27, 343), - Trans(35, 103, 27, 343), - Trans(35, 105, 27, 343), - Trans(35, 108, 27, 343), - Trans(35, 109, 27, 343), - Trans(35, 110, 27, 343), - Trans(35, 111, 27, 343), - Trans(36, 5, 27, 343), - Trans(36, 38, 27, 343), - Trans(37, 5, 27, 343), - Trans(37, 40, 27, 343), - Trans(38, 5, 27, 343), - Trans(38, 29, 27, 343), - Trans(39, 5, 27, 343), - Trans(39, 46, 27, 343), - Trans(39, 110, 27, 343), - Trans(39, 111, 27, 343), - Trans(40, 5, 27, 343), - Trans(40, 110, 27, 343), - Trans(40, 111, 27, 343), - Trans(41, 5, 27, 343), - Trans(41, 77, 27, 343), - Trans(41, 84, 27, 343), - Trans(41, 88, 27, 343), - Trans(42, 5, 27, 343), - Trans(42, 45, 27, 343), - Trans(43, 5, 27, 343), - Trans(43, 15, 27, 343), - Trans(43, 16, 27, 343), - Trans(43, 17, 27, 343), - Trans(43, 18, 27, 343), - Trans(43, 19, 27, 343), - Trans(43, 20, 27, 343), - Trans(43, 21, 27, 343), - Trans(43, 22, 27, 343), - Trans(43, 23, 27, 343), - Trans(43, 24, 27, 343), - Trans(43, 25, 27, 343), - Trans(43, 26, 27, 343), - Trans(43, 28, 27, 343), - Trans(43, 29, 27, 343), - Trans(43, 30, 27, 343), - Trans(43, 33, 27, 343), - Trans(43, 34, 27, 343), - Trans(43, 39, 27, 343), - Trans(43, 40, 27, 343), - Trans(43, 46, 27, 343), - Trans(43, 50, 27, 343), - Trans(44, 12, 27, 343), - Trans(44, 14, 27, 343), - Trans(44, 16, 27, 343), - Trans(44, 17, 27, 343), - Trans(44, 18, 27, 343), - Trans(44, 19, 27, 343), - Trans(44, 20, 27, 343), - Trans(44, 21, 27, 343), - Trans(44, 22, 27, 343), - Trans(44, 23, 27, 343), - Trans(44, 24, 27, 343), - Trans(44, 25, 27, 343), - Trans(44, 26, 27, 343), - Trans(44, 29, 27, 343), - Trans(44, 30, 27, 343), - Trans(44, 31, 27, 343), - Trans(44, 32, 27, 343), - Trans(44, 35, 27, 343), - Trans(44, 38, 27, 343), - Trans(44, 41, 27, 343), - Trans(44, 42, 27, 343), - Trans(44, 43, 27, 343), - Trans(44, 44, 27, 343), - Trans(44, 45, 27, 343), - Trans(44, 46, 27, 343), - Trans(44, 47, 27, 343), - Trans(44, 48, 27, 343), - Trans(44, 49, 27, 343), - Trans(44, 50, 27, 343), - Trans(44, 57, 27, 343), - Trans(44, 59, 27, 343), - Trans(44, 60, 27, 343), - Trans(44, 63, 27, 343), - Trans(44, 64, 27, 343), - Trans(44, 65, 27, 343), - Trans(44, 69, 27, 343), - Trans(44, 70, 27, 343), - Trans(44, 72, 27, 343), - Trans(44, 76, 27, 343), - Trans(44, 79, 27, 343), - Trans(44, 80, 27, 343), - Trans(44, 83, 27, 343), - Trans(44, 92, 27, 343), - Trans(44, 101, 27, 343), - Trans(44, 103, 27, 343), - Trans(44, 105, 27, 343), - Trans(44, 108, 27, 343), - Trans(44, 109, 27, 343), - Trans(45, 5, 27, 343), - Trans(45, 6, 27, 343), - Trans(45, 7, 27, 343), - Trans(45, 8, 27, 343), - Trans(45, 9, 27, 343), - Trans(45, 10, 27, 343), - Trans(45, 11, 27, 343), - Trans(45, 18, 27, 343), - Trans(45, 24, 27, 343), - Trans(45, 25, 27, 343), - Trans(45, 26, 27, 343), - Trans(45, 27, 27, 343), - Trans(45, 37, 27, 343), - Trans(45, 38, 27, 343), - Trans(45, 40, 27, 343), - Trans(45, 52, 27, 343), - Trans(45, 64, 27, 343), - Trans(45, 68, 27, 343), - Trans(45, 69, 27, 343), - Trans(45, 75, 27, 343), - Trans(45, 79, 27, 343), - Trans(45, 82, 27, 343), - Trans(45, 85, 27, 343), - Trans(45, 87, 27, 343), - Trans(45, 98, 27, 343), - Trans(45, 99, 27, 343), - Trans(45, 110, 27, 343), - Trans(45, 111, 27, 343), - Trans(46, 5, 27, 343), - Trans(46, 6, 27, 343), - Trans(46, 7, 27, 343), - Trans(46, 8, 27, 343), - Trans(46, 9, 27, 343), - Trans(46, 10, 27, 343), - Trans(46, 11, 27, 343), - Trans(46, 18, 27, 343), - Trans(46, 24, 27, 343), - Trans(46, 25, 27, 343), - Trans(46, 26, 27, 343), - Trans(46, 27, 27, 343), - Trans(46, 35, 27, 343), - Trans(46, 37, 27, 343), - Trans(46, 38, 27, 343), - Trans(46, 40, 27, 343), - Trans(46, 42, 27, 343), - Trans(46, 44, 27, 343), - Trans(46, 52, 27, 343), - Trans(46, 56, 27, 343), - Trans(46, 69, 27, 343), - Trans(46, 75, 27, 343), - Trans(46, 80, 27, 343), - Trans(46, 82, 27, 343), - Trans(46, 85, 27, 343), - Trans(46, 87, 27, 343), - Trans(46, 89, 27, 343), - Trans(46, 110, 27, 343), - Trans(46, 111, 27, 343), - Trans(47, 5, 27, 343), - Trans(47, 6, 27, 343), - Trans(47, 7, 27, 343), - Trans(47, 8, 27, 343), - Trans(47, 9, 27, 343), - Trans(47, 10, 27, 343), - Trans(47, 11, 27, 343), - Trans(47, 18, 27, 343), - Trans(47, 24, 27, 343), - Trans(47, 25, 27, 343), - Trans(47, 26, 27, 343), - Trans(47, 27, 27, 343), - Trans(47, 29, 27, 343), - Trans(47, 35, 27, 343), - Trans(47, 37, 27, 343), - Trans(47, 38, 27, 343), - Trans(47, 40, 27, 343), - Trans(47, 42, 27, 343), - Trans(47, 47, 27, 343), - Trans(47, 48, 27, 343), - Trans(47, 49, 27, 343), - Trans(47, 52, 27, 343), - Trans(47, 56, 27, 343), - Trans(47, 59, 27, 343), - Trans(47, 60, 27, 343), - Trans(47, 63, 27, 343), - Trans(47, 64, 27, 343), - Trans(47, 65, 27, 343), - Trans(47, 68, 27, 343), - Trans(47, 69, 27, 343), - Trans(47, 70, 27, 343), - Trans(47, 72, 27, 343), - Trans(47, 75, 27, 343), - Trans(47, 76, 27, 343), - Trans(47, 79, 27, 343), - Trans(47, 80, 27, 343), - Trans(47, 82, 27, 343), - Trans(47, 83, 27, 343), - Trans(47, 85, 27, 343), - Trans(47, 87, 27, 343), - Trans(47, 98, 27, 343), - Trans(47, 99, 27, 343), - Trans(47, 103, 27, 343), - Trans(47, 105, 27, 343), - Trans(47, 108, 27, 343), - Trans(47, 109, 27, 343), - Trans(47, 110, 27, 343), - Trans(47, 111, 27, 343), - Trans(48, 5, 27, 343), - Trans(48, 30, 27, 343), - Trans(48, 34, 27, 343), - Trans(48, 38, 27, 343), - Trans(48, 39, 27, 343), - Trans(48, 42, 27, 343), - Trans(48, 44, 27, 343), - Trans(48, 45, 27, 343), - Trans(48, 78, 27, 343), - Trans(49, 0, 27, 343), - Trans(49, 5, 27, 343), - Trans(49, 12, 27, 343), - Trans(49, 14, 27, 343), - Trans(49, 16, 27, 343), - Trans(49, 17, 27, 343), - Trans(49, 18, 27, 343), - Trans(49, 19, 27, 343), - Trans(49, 20, 27, 343), - Trans(49, 21, 27, 343), - Trans(49, 22, 27, 343), - Trans(49, 23, 27, 343), - Trans(49, 24, 27, 343), - Trans(49, 25, 27, 343), - Trans(49, 26, 27, 343), - Trans(49, 29, 27, 343), - Trans(49, 30, 27, 343), - Trans(49, 31, 27, 343), - Trans(49, 32, 27, 343), - Trans(49, 35, 27, 343), - Trans(49, 38, 27, 343), - Trans(49, 41, 27, 343), - Trans(49, 42, 27, 343), - Trans(49, 43, 27, 343), - Trans(49, 44, 27, 343), - Trans(49, 45, 27, 343), - Trans(49, 46, 27, 343), - Trans(49, 47, 27, 343), - Trans(49, 48, 27, 343), - Trans(49, 49, 27, 343), - Trans(49, 50, 27, 343), - Trans(49, 57, 27, 343), - Trans(49, 58, 27, 343), - Trans(49, 59, 27, 343), - Trans(49, 60, 27, 343), - Trans(49, 63, 27, 343), - Trans(49, 64, 27, 343), - Trans(49, 65, 27, 343), - Trans(49, 69, 27, 343), - Trans(49, 70, 27, 343), - Trans(49, 71, 27, 343), - Trans(49, 72, 27, 343), - Trans(49, 76, 27, 343), - Trans(49, 77, 27, 343), - Trans(49, 79, 27, 343), - Trans(49, 80, 27, 343), - Trans(49, 83, 27, 343), - Trans(49, 84, 27, 343), - Trans(49, 88, 27, 343), - Trans(49, 90, 27, 343), - Trans(49, 92, 27, 343), - Trans(49, 101, 27, 343), - Trans(49, 103, 27, 343), - Trans(49, 105, 27, 343), - Trans(49, 108, 27, 343), - Trans(49, 109, 27, 343), - Trans(50, 5, 27, 343), - Trans(50, 12, 27, 343), - Trans(50, 14, 27, 343), - Trans(50, 15, 27, 343), - Trans(50, 16, 27, 343), - Trans(50, 17, 27, 343), - Trans(50, 18, 27, 343), - Trans(50, 19, 27, 343), - Trans(50, 20, 27, 343), - Trans(50, 21, 27, 343), - Trans(50, 22, 27, 343), - Trans(50, 23, 27, 343), - Trans(50, 24, 27, 343), - Trans(50, 25, 27, 343), - Trans(50, 26, 27, 343), - Trans(50, 29, 27, 343), - Trans(50, 30, 27, 343), - Trans(50, 31, 27, 343), - Trans(50, 32, 27, 343), - Trans(50, 33, 27, 343), - Trans(50, 34, 27, 343), - Trans(50, 35, 27, 343), - Trans(50, 38, 27, 343), - Trans(50, 39, 27, 343), - Trans(50, 40, 27, 343), - Trans(50, 41, 27, 343), - Trans(50, 42, 27, 343), - Trans(50, 43, 27, 343), - Trans(50, 44, 27, 343), - Trans(50, 45, 27, 343), - Trans(50, 46, 27, 343), - Trans(50, 50, 27, 343), - Trans(50, 92, 27, 343), - Trans(50, 101, 27, 343), - Trans(51, 5, 27, 343), - Trans(51, 12, 27, 343), - Trans(51, 13, 27, 343), - Trans(51, 14, 27, 343), - Trans(51, 16, 27, 343), - Trans(51, 17, 27, 343), - Trans(51, 18, 27, 343), - Trans(51, 19, 27, 343), - Trans(51, 20, 27, 343), - Trans(51, 21, 27, 343), - Trans(51, 22, 27, 343), - Trans(51, 23, 27, 343), - Trans(51, 24, 27, 343), - Trans(51, 25, 27, 343), - Trans(51, 26, 27, 343), - Trans(51, 29, 27, 343), - Trans(51, 30, 27, 343), - Trans(51, 31, 27, 343), - Trans(51, 32, 27, 343), - Trans(51, 38, 27, 343), - Trans(51, 40, 27, 343), - Trans(51, 41, 27, 343), - Trans(51, 42, 27, 343), - Trans(51, 43, 27, 343), - Trans(51, 44, 27, 343), - Trans(51, 45, 27, 343), - Trans(51, 46, 27, 343), - Trans(51, 50, 27, 343), - Trans(51, 92, 27, 343), - Trans(51, 101, 27, 343), - Trans(52, 5, 27, 343), - Trans(52, 38, 27, 343), - Trans(52, 69, 27, 343), - Trans(53, 5, 27, 343), - Trans(53, 6, 27, 343), - Trans(53, 7, 27, 343), - Trans(53, 8, 27, 343), - Trans(53, 9, 27, 343), - Trans(53, 10, 27, 343), - Trans(53, 11, 27, 343), - Trans(53, 15, 27, 343), - Trans(53, 18, 27, 343), - Trans(53, 24, 27, 343), - Trans(53, 25, 27, 343), - Trans(53, 26, 27, 343), - Trans(53, 27, 27, 343), - Trans(53, 37, 27, 343), - Trans(53, 38, 27, 343), - Trans(53, 40, 27, 343), - Trans(53, 52, 27, 343), - Trans(53, 69, 27, 343), - Trans(53, 75, 27, 343), - Trans(53, 82, 27, 343), - Trans(53, 85, 27, 343), - Trans(53, 87, 27, 343), - Trans(53, 110, 27, 343), - Trans(53, 111, 27, 343), - Trans(54, 6, 27, 343), - Trans(54, 7, 27, 343), - Trans(54, 8, 27, 343), - Trans(54, 9, 27, 343), - Trans(54, 10, 27, 343), - Trans(54, 11, 27, 343), - Trans(54, 18, 27, 343), - Trans(54, 24, 27, 343), - Trans(54, 25, 27, 343), - Trans(54, 26, 27, 343), - Trans(54, 27, 27, 343), - Trans(54, 37, 27, 343), - Trans(54, 38, 27, 343), - Trans(54, 40, 27, 343), - Trans(54, 52, 27, 343), - Trans(54, 69, 27, 343), - Trans(54, 75, 27, 343), - Trans(54, 82, 27, 343), - Trans(54, 85, 27, 343), - Trans(54, 87, 27, 343), - Trans(54, 110, 27, 343), - Trans(54, 111, 27, 343), - Trans(55, 5, 27, 343), - Trans(55, 16, 27, 343), - Trans(55, 17, 27, 343), - Trans(55, 18, 27, 343), - Trans(55, 19, 27, 343), - Trans(55, 20, 27, 343), - Trans(55, 21, 27, 343), - Trans(55, 22, 27, 343), - Trans(55, 23, 27, 343), - Trans(55, 24, 27, 343), - Trans(55, 25, 27, 343), - Trans(55, 26, 27, 343), - Trans(55, 43, 27, 343), - Trans(55, 46, 27, 343), - Trans(55, 50, 27, 343), - Trans(56, 5, 27, 343), - Trans(56, 16, 27, 343), - Trans(56, 17, 27, 343), - Trans(56, 18, 27, 343), - Trans(56, 19, 27, 343), - Trans(56, 20, 27, 343), - Trans(56, 21, 27, 343), - Trans(56, 22, 27, 343), - Trans(56, 23, 27, 343), - Trans(56, 24, 27, 343), - Trans(56, 25, 27, 343), - Trans(56, 26, 27, 343), - Trans(56, 28, 27, 343), - Trans(56, 33, 27, 343), - Trans(56, 39, 27, 343), - Trans(56, 40, 27, 343), - Trans(56, 43, 27, 343), - Trans(56, 46, 27, 343), - Trans(56, 50, 27, 343), - Trans(57, 5, 27, 343), - Trans(57, 16, 27, 343), - Trans(57, 17, 27, 343), - Trans(57, 18, 27, 343), - Trans(57, 19, 27, 343), - Trans(57, 20, 27, 343), - Trans(57, 21, 27, 343), - Trans(57, 22, 27, 343), - Trans(57, 23, 27, 343), - Trans(57, 24, 27, 343), - Trans(57, 25, 27, 343), - Trans(57, 26, 27, 343), - Trans(57, 45, 27, 343), - Trans(57, 46, 27, 343), - Trans(57, 50, 27, 343), - Trans(58, 5, 27, 343), - Trans(58, 16, 27, 343), - Trans(58, 17, 27, 343), - Trans(58, 18, 27, 343), - Trans(58, 19, 27, 343), - Trans(58, 20, 27, 343), - Trans(58, 21, 27, 343), - Trans(58, 22, 27, 343), - Trans(58, 23, 27, 343), - Trans(58, 24, 27, 343), - Trans(58, 25, 27, 343), - Trans(58, 26, 27, 343), - Trans(58, 28, 27, 343), - Trans(58, 33, 27, 343), - Trans(58, 39, 27, 343), - Trans(58, 40, 27, 343), - Trans(58, 45, 27, 343), - Trans(58, 46, 27, 343), - Trans(58, 50, 27, 343), - Trans(59, 5, 27, 343), - Trans(59, 12, 27, 343), - Trans(59, 14, 27, 343), - Trans(59, 16, 27, 343), - Trans(59, 17, 27, 343), - Trans(59, 18, 27, 343), - Trans(59, 19, 27, 343), - Trans(59, 20, 27, 343), - Trans(59, 21, 27, 343), - Trans(59, 22, 27, 343), - Trans(59, 23, 27, 343), - Trans(59, 24, 27, 343), - Trans(59, 25, 27, 343), - Trans(59, 26, 27, 343), - Trans(59, 29, 27, 343), - Trans(59, 30, 27, 343), - Trans(59, 31, 27, 343), - Trans(59, 32, 27, 343), - Trans(59, 38, 27, 343), - Trans(59, 41, 27, 343), - Trans(59, 42, 27, 343), - Trans(59, 43, 27, 343), - Trans(59, 44, 27, 343), - Trans(59, 45, 27, 343), - Trans(59, 46, 27, 343), - Trans(59, 50, 27, 343), - Trans(59, 92, 27, 343), - Trans(59, 101, 27, 343), - Trans(60, 5, 27, 343), - Trans(60, 12, 27, 343), - Trans(60, 14, 27, 343), - Trans(60, 16, 27, 343), - Trans(60, 17, 27, 343), - Trans(60, 18, 27, 343), - Trans(60, 19, 27, 343), - Trans(60, 20, 27, 343), - Trans(60, 21, 27, 343), - Trans(60, 22, 27, 343), - Trans(60, 23, 27, 343), - Trans(60, 24, 27, 343), - Trans(60, 25, 27, 343), - Trans(60, 26, 27, 343), - Trans(60, 28, 27, 343), - Trans(60, 29, 27, 343), - Trans(60, 30, 27, 343), - Trans(60, 31, 27, 343), - Trans(60, 32, 27, 343), - Trans(60, 33, 27, 343), - Trans(60, 38, 27, 343), - Trans(60, 39, 27, 343), - Trans(60, 40, 27, 343), - Trans(60, 41, 27, 343), - Trans(60, 42, 27, 343), - Trans(60, 43, 27, 343), - Trans(60, 44, 27, 343), - Trans(60, 45, 27, 343), - Trans(60, 46, 27, 343), - Trans(60, 50, 27, 343), - Trans(60, 92, 27, 343), - Trans(60, 101, 27, 343), - Trans(61, 6, 27, 343), - Trans(61, 7, 27, 343), - Trans(61, 8, 27, 343), - Trans(61, 9, 27, 343), - Trans(61, 10, 27, 343), - Trans(61, 11, 27, 343), - Trans(61, 18, 27, 343), - Trans(61, 24, 27, 343), - Trans(61, 25, 27, 343), - Trans(61, 26, 27, 343), - Trans(61, 27, 27, 343), - Trans(61, 37, 27, 343), - Trans(61, 38, 27, 343), - Trans(61, 40, 27, 343), - Trans(61, 52, 27, 343), - Trans(61, 64, 27, 343), - Trans(61, 68, 27, 343), - Trans(61, 69, 27, 343), - Trans(61, 75, 27, 343), - Trans(61, 79, 27, 343), - Trans(61, 82, 27, 343), - Trans(61, 85, 27, 343), - Trans(61, 87, 27, 343), - Trans(61, 98, 27, 343), - Trans(61, 99, 27, 343), - Trans(61, 110, 27, 343), - Trans(61, 111, 27, 343), - Trans(62, 5, 27, 343), - Trans(62, 16, 27, 343), - Trans(62, 17, 27, 343), - Trans(62, 18, 27, 343), - Trans(62, 19, 27, 343), - Trans(62, 20, 27, 343), - Trans(62, 21, 27, 343), - Trans(62, 22, 27, 343), - Trans(62, 23, 27, 343), - Trans(62, 24, 27, 343), - Trans(62, 25, 27, 343), - Trans(62, 26, 27, 343), - Trans(62, 30, 27, 343), - Trans(62, 43, 27, 343), - Trans(62, 46, 27, 343), - Trans(62, 50, 27, 343), - Trans(63, 5, 27, 343), - Trans(63, 6, 27, 343), - Trans(63, 7, 27, 343), - Trans(63, 8, 27, 343), - Trans(63, 9, 27, 343), - Trans(63, 10, 27, 343), - Trans(63, 11, 27, 343), - Trans(63, 18, 27, 343), - Trans(63, 24, 27, 343), - Trans(63, 25, 27, 343), - Trans(63, 26, 27, 343), - Trans(63, 27, 27, 343), - Trans(63, 37, 27, 343), - Trans(63, 38, 27, 343), - Trans(63, 40, 27, 343), - Trans(63, 42, 27, 343), - Trans(63, 52, 27, 343), - Trans(63, 64, 27, 343), - Trans(63, 68, 27, 343), - Trans(63, 69, 27, 343), - Trans(63, 75, 27, 343), - Trans(63, 79, 27, 343), - Trans(63, 82, 27, 343), - Trans(63, 85, 27, 343), - Trans(63, 87, 27, 343), - Trans(63, 98, 27, 343), - Trans(63, 99, 27, 343), - Trans(63, 110, 27, 343), - Trans(63, 111, 27, 343), - Trans(64, 5, 27, 343), - Trans(64, 15, 27, 343), - Trans(64, 16, 27, 343), - Trans(64, 17, 27, 343), - Trans(64, 18, 27, 343), - Trans(64, 19, 27, 343), - Trans(64, 20, 27, 343), - Trans(64, 21, 27, 343), - Trans(64, 22, 27, 343), - Trans(64, 23, 27, 343), - Trans(64, 24, 27, 343), - Trans(64, 25, 27, 343), - Trans(64, 26, 27, 343), - Trans(64, 28, 27, 343), - Trans(64, 30, 27, 343), - Trans(64, 33, 27, 343), - Trans(64, 34, 27, 343), - Trans(64, 39, 27, 343), - Trans(64, 40, 27, 343), - Trans(64, 43, 27, 343), - Trans(64, 46, 27, 343), - Trans(64, 50, 27, 343), - Trans(65, 5, 27, 343), - Trans(65, 15, 27, 343), - Trans(65, 16, 27, 343), - Trans(65, 17, 27, 343), - Trans(65, 18, 27, 343), - Trans(65, 19, 27, 343), - Trans(65, 20, 27, 343), - Trans(65, 21, 27, 343), - Trans(65, 22, 27, 343), - Trans(65, 23, 27, 343), - Trans(65, 24, 27, 343), - Trans(65, 25, 27, 343), - Trans(65, 26, 27, 343), - Trans(65, 28, 27, 343), - Trans(65, 30, 27, 343), - Trans(65, 33, 27, 343), - Trans(65, 34, 27, 343), - Trans(65, 38, 27, 343), - Trans(65, 39, 27, 343), - Trans(65, 40, 27, 343), - Trans(65, 43, 27, 343), - Trans(65, 46, 27, 343), - Trans(65, 50, 27, 343), - Trans(66, 6, 27, 343), - Trans(66, 7, 27, 343), - Trans(66, 8, 27, 343), - Trans(66, 9, 27, 343), - Trans(66, 10, 27, 343), - Trans(66, 11, 27, 343), - Trans(66, 18, 27, 343), - Trans(66, 24, 27, 343), - Trans(66, 25, 27, 343), - Trans(66, 26, 27, 343), - Trans(66, 27, 27, 343), - Trans(66, 35, 27, 343), - Trans(66, 37, 27, 343), - Trans(66, 38, 27, 343), - Trans(66, 40, 27, 343), - Trans(66, 42, 27, 343), - Trans(66, 44, 27, 343), - Trans(66, 52, 27, 343), - Trans(66, 56, 27, 343), - Trans(66, 69, 27, 343), - Trans(66, 75, 27, 343), - Trans(66, 80, 27, 343), - Trans(66, 82, 27, 343), - Trans(66, 85, 27, 343), - Trans(66, 87, 27, 343), - Trans(66, 89, 27, 343), - Trans(66, 110, 27, 343), - Trans(66, 111, 27, 343), - Trans(67, 5, 27, 343), - Trans(67, 16, 27, 343), - Trans(67, 17, 27, 343), - Trans(67, 18, 27, 343), - Trans(67, 19, 27, 343), - Trans(67, 20, 27, 343), - Trans(67, 21, 27, 343), - Trans(67, 22, 27, 343), - Trans(67, 23, 27, 343), - Trans(67, 24, 27, 343), - Trans(67, 25, 27, 343), - Trans(67, 26, 27, 343), - Trans(67, 29, 27, 343), - Trans(67, 30, 27, 343), - Trans(67, 31, 27, 343), - Trans(67, 32, 27, 343), - Trans(67, 41, 27, 343), - Trans(67, 42, 27, 343), - Trans(67, 43, 27, 343), - Trans(67, 44, 27, 343), - Trans(67, 46, 27, 343), - Trans(67, 50, 27, 343), - Trans(67, 92, 27, 343), - Trans(68, 5, 27, 343), - Trans(68, 6, 27, 343), - Trans(68, 7, 27, 343), - Trans(68, 8, 27, 343), - Trans(68, 9, 27, 343), - Trans(68, 10, 27, 343), - Trans(68, 11, 27, 343), - Trans(68, 18, 27, 343), - Trans(68, 24, 27, 343), - Trans(68, 25, 27, 343), - Trans(68, 26, 27, 343), - Trans(68, 27, 27, 343), - Trans(68, 35, 27, 343), - Trans(68, 37, 27, 343), - Trans(68, 38, 27, 343), - Trans(68, 40, 27, 343), - Trans(68, 52, 27, 343), - Trans(68, 69, 27, 343), - Trans(68, 75, 27, 343), - Trans(68, 80, 27, 343), - Trans(68, 82, 27, 343), - Trans(68, 85, 27, 343), - Trans(68, 87, 27, 343), - Trans(68, 89, 27, 343), - Trans(68, 110, 27, 343), - Trans(68, 111, 27, 343), - Trans(69, 5, 27, 343), - Trans(69, 12, 27, 343), - Trans(69, 14, 27, 343), - Trans(69, 16, 27, 343), - Trans(69, 17, 27, 343), - Trans(69, 18, 27, 343), - Trans(69, 19, 27, 343), - Trans(69, 20, 27, 343), - Trans(69, 21, 27, 343), - Trans(69, 22, 27, 343), - Trans(69, 23, 27, 343), - Trans(69, 24, 27, 343), - Trans(69, 25, 27, 343), - Trans(69, 26, 27, 343), - Trans(69, 29, 27, 343), - Trans(69, 30, 27, 343), - Trans(69, 31, 27, 343), - Trans(69, 32, 27, 343), - Trans(69, 35, 27, 343), - Trans(69, 38, 27, 343), - Trans(69, 41, 27, 343), - Trans(69, 42, 27, 343), - Trans(69, 43, 27, 343), - Trans(69, 44, 27, 343), - Trans(69, 45, 27, 343), - Trans(69, 46, 27, 343), - Trans(69, 47, 27, 343), - Trans(69, 48, 27, 343), - Trans(69, 49, 27, 343), - Trans(69, 50, 27, 343), - Trans(69, 59, 27, 343), - Trans(69, 60, 27, 343), - Trans(69, 63, 27, 343), - Trans(69, 64, 27, 343), - Trans(69, 65, 27, 343), - Trans(69, 69, 27, 343), - Trans(69, 70, 27, 343), - Trans(69, 72, 27, 343), - Trans(69, 76, 27, 343), - Trans(69, 79, 27, 343), - Trans(69, 80, 27, 343), - Trans(69, 83, 27, 343), - Trans(69, 92, 27, 343), - Trans(69, 101, 27, 343), - Trans(69, 103, 27, 343), - Trans(69, 105, 27, 343), - Trans(69, 108, 27, 343), - Trans(69, 109, 27, 343), - Trans(70, 5, 27, 343), - Trans(70, 16, 27, 343), - Trans(70, 17, 27, 343), - Trans(70, 18, 27, 343), - Trans(70, 19, 27, 343), - Trans(70, 20, 27, 343), - Trans(70, 21, 27, 343), - Trans(70, 22, 27, 343), - Trans(70, 23, 27, 343), - Trans(70, 24, 27, 343), - Trans(70, 25, 27, 343), - Trans(70, 26, 27, 343), - Trans(70, 28, 27, 343), - Trans(70, 29, 27, 343), - Trans(70, 30, 27, 343), - Trans(70, 31, 27, 343), - Trans(70, 32, 27, 343), - Trans(70, 33, 27, 343), - Trans(70, 39, 27, 343), - Trans(70, 40, 27, 343), - Trans(70, 41, 27, 343), - Trans(70, 42, 27, 343), - Trans(70, 43, 27, 343), - Trans(70, 44, 27, 343), - Trans(70, 46, 27, 343), - Trans(70, 50, 27, 343), - Trans(70, 92, 27, 343), - Trans(71, 5, 27, 343), - Trans(71, 16, 27, 343), - Trans(71, 17, 27, 343), - Trans(71, 18, 27, 343), - Trans(71, 19, 27, 343), - Trans(71, 20, 27, 343), - Trans(71, 21, 27, 343), - Trans(71, 22, 27, 343), - Trans(71, 23, 27, 343), - Trans(71, 24, 27, 343), - Trans(71, 25, 27, 343), - Trans(71, 26, 27, 343), - Trans(71, 28, 27, 343), - Trans(71, 29, 27, 343), - Trans(71, 30, 27, 343), - Trans(71, 31, 27, 343), - Trans(71, 32, 27, 343), - Trans(71, 33, 27, 343), - Trans(71, 34, 27, 343), - Trans(71, 39, 27, 343), - Trans(71, 40, 27, 343), - Trans(71, 41, 27, 343), - Trans(71, 42, 27, 343), - Trans(71, 43, 27, 343), - Trans(71, 44, 27, 343), - Trans(71, 46, 27, 343), - Trans(71, 50, 27, 343), - Trans(71, 92, 27, 343), - Trans(72, 5, 27, 343), - Trans(72, 16, 27, 343), - Trans(72, 17, 27, 343), - Trans(72, 18, 27, 343), - Trans(72, 19, 27, 343), - Trans(72, 20, 27, 343), - Trans(72, 21, 27, 343), - Trans(72, 22, 27, 343), - Trans(72, 23, 27, 343), - Trans(72, 24, 27, 343), - Trans(72, 25, 27, 343), - Trans(72, 26, 27, 343), - Trans(72, 29, 27, 343), - Trans(72, 30, 27, 343), - Trans(72, 38, 27, 343), - Trans(72, 42, 27, 343), - Trans(72, 46, 27, 343), - Trans(72, 50, 27, 343), - Trans(72, 101, 27, 343), - Trans(73, 5, 27, 343), - Trans(73, 16, 27, 343), - Trans(73, 17, 27, 343), - Trans(73, 18, 27, 343), - Trans(73, 19, 27, 343), - Trans(73, 20, 27, 343), - Trans(73, 21, 27, 343), - Trans(73, 22, 27, 343), - Trans(73, 23, 27, 343), - Trans(73, 24, 27, 343), - Trans(73, 25, 27, 343), - Trans(73, 26, 27, 343), - Trans(73, 28, 27, 343), - Trans(73, 29, 27, 343), - Trans(73, 30, 27, 343), - Trans(73, 33, 27, 343), - Trans(73, 38, 27, 343), - Trans(73, 39, 27, 343), - Trans(73, 40, 27, 343), - Trans(73, 42, 27, 343), - Trans(73, 46, 27, 343), - Trans(73, 50, 27, 343), - Trans(73, 101, 27, 343), - Trans(74, 5, 27, 343), - Trans(74, 16, 27, 343), - Trans(74, 17, 27, 343), - Trans(74, 18, 27, 343), - Trans(74, 19, 27, 343), - Trans(74, 20, 27, 343), - Trans(74, 21, 27, 343), - Trans(74, 22, 27, 343), - Trans(74, 23, 27, 343), - Trans(74, 24, 27, 343), - Trans(74, 25, 27, 343), - Trans(74, 26, 27, 343), - Trans(74, 30, 27, 343), - Trans(74, 42, 27, 343), - Trans(74, 44, 27, 343), - Trans(74, 45, 27, 343), - Trans(74, 46, 27, 343), - Trans(74, 50, 27, 343), - Trans(75, 5, 27, 343), - Trans(75, 16, 27, 343), - Trans(75, 17, 27, 343), - Trans(75, 18, 27, 343), - Trans(75, 19, 27, 343), - Trans(75, 20, 27, 343), - Trans(75, 21, 27, 343), - Trans(75, 22, 27, 343), - Trans(75, 23, 27, 343), - Trans(75, 24, 27, 343), - Trans(75, 25, 27, 343), - Trans(75, 26, 27, 343), - Trans(75, 28, 27, 343), - Trans(75, 30, 27, 343), - Trans(75, 33, 27, 343), - Trans(75, 39, 27, 343), - Trans(75, 40, 27, 343), - Trans(75, 42, 27, 343), - Trans(75, 44, 27, 343), - Trans(75, 45, 27, 343), - Trans(75, 46, 27, 343), - Trans(75, 50, 27, 343), - Trans(76, 5, 27, 343), - Trans(76, 16, 27, 343), - Trans(76, 17, 27, 343), - Trans(76, 18, 27, 343), - Trans(76, 19, 27, 343), - Trans(76, 20, 27, 343), - Trans(76, 21, 27, 343), - Trans(76, 22, 27, 343), - Trans(76, 23, 27, 343), - Trans(76, 24, 27, 343), - Trans(76, 25, 27, 343), - Trans(76, 26, 27, 343), - Trans(76, 30, 27, 343), - Trans(76, 41, 27, 343), - Trans(76, 46, 27, 343), - Trans(76, 50, 27, 343), - Trans(77, 5, 27, 343), - Trans(77, 16, 27, 343), - Trans(77, 17, 27, 343), - Trans(77, 18, 27, 343), - Trans(77, 19, 27, 343), - Trans(77, 20, 27, 343), - Trans(77, 21, 27, 343), - Trans(77, 22, 27, 343), - Trans(77, 23, 27, 343), - Trans(77, 24, 27, 343), - Trans(77, 25, 27, 343), - Trans(77, 26, 27, 343), - Trans(77, 28, 27, 343), - Trans(77, 30, 27, 343), - Trans(77, 33, 27, 343), - Trans(77, 39, 27, 343), - Trans(77, 40, 27, 343), - Trans(77, 41, 27, 343), - Trans(77, 46, 27, 343), - Trans(77, 50, 27, 343), - Trans(78, 6, 27, 343), - Trans(78, 7, 27, 343), - Trans(78, 8, 27, 343), - Trans(78, 9, 27, 343), - Trans(78, 10, 27, 343), - Trans(78, 11, 27, 343), - Trans(78, 18, 27, 343), - Trans(78, 24, 27, 343), - Trans(78, 25, 27, 343), - Trans(78, 26, 27, 343), - Trans(78, 27, 27, 343), - Trans(78, 29, 27, 343), - Trans(78, 35, 27, 343), - Trans(78, 37, 27, 343), - Trans(78, 38, 27, 343), - Trans(78, 40, 27, 343), - Trans(78, 42, 27, 343), - Trans(78, 47, 27, 343), - Trans(78, 48, 27, 343), - Trans(78, 49, 27, 343), - Trans(78, 52, 27, 343), - Trans(78, 56, 27, 343), - Trans(78, 59, 27, 343), - Trans(78, 63, 27, 343), - Trans(78, 64, 27, 343), - Trans(78, 65, 27, 343), - Trans(78, 68, 27, 343), - Trans(78, 69, 27, 343), - Trans(78, 70, 27, 343), - Trans(78, 72, 27, 343), - Trans(78, 75, 27, 343), - Trans(78, 76, 27, 343), - Trans(78, 79, 27, 343), - Trans(78, 80, 27, 343), - Trans(78, 82, 27, 343), - Trans(78, 83, 27, 343), - Trans(78, 85, 27, 343), - Trans(78, 87, 27, 343), - Trans(78, 98, 27, 343), - Trans(78, 99, 27, 343), - Trans(78, 103, 27, 343), - Trans(78, 105, 27, 343), - Trans(78, 108, 27, 343), - Trans(78, 109, 27, 343), - Trans(78, 110, 27, 343), - Trans(78, 111, 27, 343), - Trans(79, 5, 27, 343), - Trans(79, 16, 27, 343), - Trans(79, 17, 27, 343), - Trans(79, 18, 27, 343), - Trans(79, 19, 27, 343), - Trans(79, 20, 27, 343), - Trans(79, 21, 27, 343), - Trans(79, 22, 27, 343), - Trans(79, 23, 27, 343), - Trans(79, 24, 27, 343), - Trans(79, 25, 27, 343), - Trans(79, 26, 27, 343), - Trans(79, 29, 27, 343), - Trans(79, 30, 27, 343), - Trans(79, 31, 27, 343), - Trans(79, 32, 27, 343), - Trans(79, 42, 27, 343), - Trans(79, 46, 27, 343), - Trans(79, 50, 27, 343), - Trans(80, 5, 27, 343), - Trans(80, 6, 27, 343), - Trans(80, 7, 27, 343), - Trans(80, 8, 27, 343), - Trans(80, 9, 27, 343), - Trans(80, 10, 27, 343), - Trans(80, 11, 27, 343), - Trans(80, 18, 27, 343), - Trans(80, 24, 27, 343), - Trans(80, 25, 27, 343), - Trans(80, 26, 27, 343), - Trans(80, 27, 27, 343), - Trans(80, 29, 27, 343), - Trans(80, 35, 27, 343), - Trans(80, 37, 27, 343), - Trans(80, 38, 27, 343), - Trans(80, 40, 27, 343), - Trans(80, 42, 27, 343), - Trans(80, 47, 27, 343), - Trans(80, 48, 27, 343), - Trans(80, 49, 27, 343), - Trans(80, 52, 27, 343), - Trans(80, 59, 27, 343), - Trans(80, 63, 27, 343), - Trans(80, 64, 27, 343), - Trans(80, 65, 27, 343), - Trans(80, 69, 27, 343), - Trans(80, 70, 27, 343), - Trans(80, 72, 27, 343), - Trans(80, 75, 27, 343), - Trans(80, 76, 27, 343), - Trans(80, 79, 27, 343), - Trans(80, 80, 27, 343), - Trans(80, 82, 27, 343), - Trans(80, 83, 27, 343), - Trans(80, 85, 27, 343), - Trans(80, 87, 27, 343), - Trans(80, 103, 27, 343), - Trans(80, 105, 27, 343), - Trans(80, 108, 27, 343), - Trans(80, 109, 27, 343), - Trans(80, 110, 27, 343), - Trans(80, 111, 27, 343), - Trans(81, 5, 27, 343), - Trans(81, 6, 27, 343), - Trans(81, 7, 27, 343), - Trans(81, 8, 27, 343), - Trans(81, 9, 27, 343), - Trans(81, 10, 27, 343), - Trans(81, 11, 27, 343), - Trans(81, 18, 27, 343), - Trans(81, 24, 27, 343), - Trans(81, 25, 27, 343), - Trans(81, 26, 27, 343), - Trans(81, 27, 27, 343), - Trans(81, 29, 27, 343), - Trans(81, 35, 27, 343), - Trans(81, 37, 27, 343), - Trans(81, 38, 27, 343), - Trans(81, 40, 27, 343), - Trans(81, 42, 27, 343), - Trans(81, 47, 27, 343), - Trans(81, 48, 27, 343), - Trans(81, 49, 27, 343), - Trans(81, 52, 27, 343), - Trans(81, 56, 27, 343), - Trans(81, 57, 27, 343), - Trans(81, 59, 27, 343), - Trans(81, 60, 27, 343), - Trans(81, 63, 27, 343), - Trans(81, 64, 27, 343), - Trans(81, 65, 27, 343), - Trans(81, 68, 27, 343), - Trans(81, 69, 27, 343), - Trans(81, 70, 27, 343), - Trans(81, 72, 27, 343), - Trans(81, 75, 27, 343), - Trans(81, 76, 27, 343), - Trans(81, 79, 27, 343), - Trans(81, 80, 27, 343), - Trans(81, 82, 27, 343), - Trans(81, 83, 27, 343), - Trans(81, 85, 27, 343), - Trans(81, 87, 27, 343), - Trans(81, 98, 27, 343), - Trans(81, 99, 27, 343), - Trans(81, 103, 27, 343), - Trans(81, 105, 27, 343), - Trans(81, 108, 27, 343), - Trans(81, 109, 27, 343), - Trans(81, 110, 27, 343), - Trans(81, 111, 27, 343), - Trans(82, 5, 27, 343), - Trans(82, 15, 27, 343), - Trans(82, 16, 27, 343), - Trans(82, 17, 27, 343), - Trans(82, 18, 27, 343), - Trans(82, 19, 27, 343), - Trans(82, 20, 27, 343), - Trans(82, 21, 27, 343), - Trans(82, 22, 27, 343), - Trans(82, 23, 27, 343), - Trans(82, 24, 27, 343), - Trans(82, 25, 27, 343), - Trans(82, 26, 27, 343), - Trans(82, 28, 27, 343), - Trans(82, 29, 27, 343), - Trans(82, 30, 27, 343), - Trans(82, 31, 27, 343), - Trans(82, 32, 27, 343), - Trans(82, 33, 27, 343), - Trans(82, 34, 27, 343), - Trans(82, 39, 27, 343), - Trans(82, 40, 27, 343), - Trans(82, 42, 27, 343), - Trans(82, 46, 27, 343), - Trans(82, 50, 27, 343), - Trans(83, 5, 27, 343), - Trans(83, 12, 27, 343), - Trans(83, 14, 27, 343), - Trans(83, 16, 27, 343), - Trans(83, 17, 27, 343), - Trans(83, 18, 27, 343), - Trans(83, 19, 27, 343), - Trans(83, 20, 27, 343), - Trans(83, 21, 27, 343), - Trans(83, 22, 27, 343), - Trans(83, 23, 27, 343), - Trans(83, 24, 27, 343), - Trans(83, 25, 27, 343), - Trans(83, 26, 27, 343), - Trans(83, 29, 27, 343), - Trans(83, 30, 27, 343), - Trans(83, 43, 27, 343), - Trans(83, 46, 27, 343), - Trans(83, 50, 27, 343), - Trans(83, 101, 27, 343), - Trans(84, 5, 27, 343), - Trans(84, 12, 27, 343), - Trans(84, 14, 27, 343), - Trans(84, 16, 27, 343), - Trans(84, 17, 27, 343), - Trans(84, 18, 27, 343), - Trans(84, 19, 27, 343), - Trans(84, 20, 27, 343), - Trans(84, 21, 27, 343), - Trans(84, 22, 27, 343), - Trans(84, 23, 27, 343), - Trans(84, 24, 27, 343), - Trans(84, 25, 27, 343), - Trans(84, 26, 27, 343), - Trans(84, 28, 27, 343), - Trans(84, 29, 27, 343), - Trans(84, 30, 27, 343), - Trans(84, 33, 27, 343), - Trans(84, 39, 27, 343), - Trans(84, 40, 27, 343), - Trans(84, 43, 27, 343), - Trans(84, 46, 27, 343), - Trans(84, 50, 27, 343), - Trans(84, 101, 27, 343), - Trans(85, 6, 27, 343), - Trans(85, 7, 27, 343), - Trans(85, 8, 27, 343), - Trans(85, 9, 27, 343), - Trans(85, 10, 27, 343), - Trans(85, 11, 27, 343), - Trans(85, 18, 27, 343), - Trans(85, 24, 27, 343), - Trans(85, 25, 27, 343), - Trans(85, 26, 27, 343), - Trans(85, 27, 27, 343), - Trans(85, 35, 27, 343), - Trans(85, 37, 27, 343), - Trans(85, 38, 27, 343), - Trans(85, 40, 27, 343), - Trans(85, 44, 27, 343), - Trans(85, 52, 27, 343), - Trans(85, 69, 27, 343), - Trans(85, 75, 27, 343), - Trans(85, 82, 27, 343), - Trans(85, 85, 27, 343), - Trans(85, 87, 27, 343), - Trans(85, 110, 27, 343), - Trans(85, 111, 27, 343), - Trans(86, 5, 27, 343), - Trans(86, 16, 27, 343), - Trans(86, 17, 27, 343), - Trans(86, 18, 27, 343), - Trans(86, 19, 27, 343), - Trans(86, 20, 27, 343), - Trans(86, 21, 27, 343), - Trans(86, 22, 27, 343), - Trans(86, 23, 27, 343), - Trans(86, 24, 27, 343), - Trans(86, 25, 27, 343), - Trans(86, 26, 27, 343), - Trans(86, 30, 27, 343), - Trans(86, 44, 27, 343), - Trans(86, 46, 27, 343), - Trans(86, 50, 27, 343), - Trans(87, 5, 27, 343), - Trans(87, 6, 27, 343), - Trans(87, 7, 27, 343), - Trans(87, 8, 27, 343), - Trans(87, 9, 27, 343), - Trans(87, 10, 27, 343), - Trans(87, 11, 27, 343), - Trans(87, 18, 27, 343), - Trans(87, 24, 27, 343), - Trans(87, 25, 27, 343), - Trans(87, 26, 27, 343), - Trans(87, 27, 27, 343), - Trans(87, 35, 27, 343), - Trans(87, 37, 27, 343), - Trans(87, 38, 27, 343), - Trans(87, 40, 27, 343), - Trans(87, 52, 27, 343), - Trans(87, 69, 27, 343), - Trans(87, 75, 27, 343), - Trans(87, 82, 27, 343), - Trans(87, 85, 27, 343), - Trans(87, 87, 27, 343), - Trans(87, 110, 27, 343), - Trans(87, 111, 27, 343), - Trans(88, 5, 27, 343), - Trans(88, 16, 27, 343), - Trans(88, 17, 27, 343), - Trans(88, 18, 27, 343), - Trans(88, 19, 27, 343), - Trans(88, 20, 27, 343), - Trans(88, 21, 27, 343), - Trans(88, 22, 27, 343), - Trans(88, 23, 27, 343), - Trans(88, 24, 27, 343), - Trans(88, 25, 27, 343), - Trans(88, 26, 27, 343), - Trans(88, 28, 27, 343), - Trans(88, 30, 27, 343), - Trans(88, 33, 27, 343), - Trans(88, 39, 27, 343), - Trans(88, 40, 27, 343), - Trans(88, 44, 27, 343), - Trans(88, 46, 27, 343), - Trans(88, 50, 27, 343), - Trans(89, 5, 27, 343), - Trans(89, 16, 27, 343), - Trans(89, 17, 27, 343), - Trans(89, 18, 27, 343), - Trans(89, 19, 27, 343), - Trans(89, 20, 27, 343), - Trans(89, 21, 27, 343), - Trans(89, 22, 27, 343), - Trans(89, 23, 27, 343), - Trans(89, 24, 27, 343), - Trans(89, 25, 27, 343), - Trans(89, 26, 27, 343), - Trans(89, 28, 27, 343), - Trans(89, 29, 27, 343), - Trans(89, 30, 27, 343), - Trans(89, 33, 27, 343), - Trans(89, 39, 27, 343), - Trans(89, 40, 27, 343), - Trans(89, 44, 27, 343), - Trans(89, 46, 27, 343), - Trans(89, 50, 27, 343), - Trans(90, 5, 27, 343), - Trans(90, 16, 27, 343), - Trans(90, 17, 27, 343), - Trans(90, 18, 27, 343), - Trans(90, 19, 27, 343), - Trans(90, 20, 27, 343), - Trans(90, 21, 27, 343), - Trans(90, 22, 27, 343), - Trans(90, 23, 27, 343), - Trans(90, 24, 27, 343), - Trans(90, 25, 27, 343), - Trans(90, 26, 27, 343), - Trans(90, 31, 27, 343), - Trans(90, 32, 27, 343), - Trans(90, 38, 27, 343), - Trans(90, 46, 27, 343), - Trans(90, 50, 27, 343), - Trans(90, 101, 27, 343), - Trans(91, 5, 27, 343), - Trans(91, 16, 27, 343), - Trans(91, 17, 27, 343), - Trans(91, 18, 27, 343), - Trans(91, 19, 27, 343), - Trans(91, 20, 27, 343), - Trans(91, 21, 27, 343), - Trans(91, 22, 27, 343), - Trans(91, 23, 27, 343), - Trans(91, 24, 27, 343), - Trans(91, 25, 27, 343), - Trans(91, 26, 27, 343), - Trans(91, 28, 27, 343), - Trans(91, 31, 27, 343), - Trans(91, 32, 27, 343), - Trans(91, 33, 27, 343), - Trans(91, 38, 27, 343), - Trans(91, 39, 27, 343), - Trans(91, 40, 27, 343), - Trans(91, 46, 27, 343), - Trans(91, 50, 27, 343), - Trans(91, 101, 27, 343), - Trans(92, 5, 27, 343), - Trans(92, 16, 27, 343), - Trans(92, 17, 27, 343), - Trans(92, 18, 27, 343), - Trans(92, 19, 27, 343), - Trans(92, 20, 27, 343), - Trans(92, 21, 27, 343), - Trans(92, 22, 27, 343), - Trans(92, 23, 27, 343), - Trans(92, 24, 27, 343), - Trans(92, 25, 27, 343), - Trans(92, 26, 27, 343), - Trans(92, 30, 27, 343), - Trans(92, 42, 27, 343), - Trans(92, 46, 27, 343), - Trans(92, 50, 27, 343), - Trans(93, 5, 27, 343), - Trans(93, 16, 27, 343), - Trans(93, 17, 27, 343), - Trans(93, 18, 27, 343), - Trans(93, 19, 27, 343), - Trans(93, 20, 27, 343), - Trans(93, 21, 27, 343), - Trans(93, 22, 27, 343), - Trans(93, 23, 27, 343), - Trans(93, 24, 27, 343), - Trans(93, 25, 27, 343), - Trans(93, 26, 27, 343), - Trans(93, 28, 27, 343), - Trans(93, 30, 27, 343), - Trans(93, 33, 27, 343), - Trans(93, 39, 27, 343), - Trans(93, 40, 27, 343), - Trans(93, 42, 27, 343), - Trans(93, 46, 27, 343), - Trans(93, 50, 27, 343), - Trans(94, 6, 27, 343), - Trans(94, 7, 27, 343), - Trans(94, 8, 27, 343), - Trans(94, 9, 27, 343), - Trans(94, 10, 27, 343), - Trans(94, 11, 27, 343), - Trans(94, 15, 27, 343), - Trans(94, 18, 27, 343), - Trans(94, 24, 27, 343), - Trans(94, 25, 27, 343), - Trans(94, 26, 27, 343), - Trans(94, 27, 27, 343), - Trans(94, 37, 27, 343), - Trans(94, 38, 27, 343), - Trans(94, 40, 27, 343), - Trans(94, 52, 27, 343), - Trans(94, 69, 27, 343), - Trans(94, 75, 27, 343), - Trans(94, 82, 27, 343), - Trans(94, 85, 27, 343), - Trans(94, 87, 27, 343), - Trans(94, 110, 27, 343), - Trans(94, 111, 27, 343), - Trans(95, 12, 27, 343), - Trans(95, 14, 27, 343), - Trans(95, 15, 27, 343), - Trans(95, 16, 27, 343), - Trans(95, 17, 27, 343), - Trans(95, 18, 27, 343), - Trans(95, 19, 27, 343), - Trans(95, 20, 27, 343), - Trans(95, 21, 27, 343), - Trans(95, 22, 27, 343), - Trans(95, 23, 27, 343), - Trans(95, 24, 27, 343), - Trans(95, 25, 27, 343), - Trans(95, 26, 27, 343), - Trans(95, 29, 27, 343), - Trans(95, 30, 27, 343), - Trans(95, 31, 27, 343), - Trans(95, 32, 27, 343), - Trans(95, 33, 27, 343), - Trans(95, 34, 27, 343), - Trans(95, 35, 27, 343), - Trans(95, 38, 27, 343), - Trans(95, 39, 27, 343), - Trans(95, 40, 27, 343), - Trans(95, 41, 27, 343), - Trans(95, 42, 27, 343), - Trans(95, 43, 27, 343), - Trans(95, 44, 27, 343), - Trans(95, 45, 27, 343), - Trans(95, 46, 27, 343), - Trans(95, 50, 27, 343), - Trans(95, 92, 27, 343), - Trans(95, 101, 27, 343), - Trans(96, 5, 27, 343), - Trans(96, 6, 27, 343), - Trans(96, 7, 27, 343), - Trans(96, 8, 27, 343), - Trans(96, 9, 27, 343), - Trans(96, 10, 27, 343), - Trans(96, 11, 27, 343), - Trans(96, 18, 27, 343), - Trans(96, 24, 27, 343), - Trans(96, 25, 27, 343), - Trans(96, 26, 27, 343), - Trans(96, 27, 27, 343), - Trans(96, 29, 27, 343), - Trans(96, 35, 27, 343), - Trans(96, 37, 27, 343), - Trans(96, 38, 27, 343), - Trans(96, 40, 27, 343), - Trans(96, 42, 27, 343), - Trans(96, 47, 27, 343), - Trans(96, 48, 27, 343), - Trans(96, 49, 27, 343), - Trans(96, 52, 27, 343), - Trans(96, 56, 27, 343), - Trans(96, 59, 27, 343), - Trans(96, 63, 27, 343), - Trans(96, 64, 27, 343), - Trans(96, 65, 27, 343), - Trans(96, 68, 27, 343), - Trans(96, 69, 27, 343), - Trans(96, 70, 27, 343), - Trans(96, 72, 27, 343), - Trans(96, 75, 27, 343), - Trans(96, 76, 27, 343), - Trans(96, 79, 27, 343), - Trans(96, 80, 27, 343), - Trans(96, 82, 27, 343), - Trans(96, 83, 27, 343), - Trans(96, 85, 27, 343), - Trans(96, 87, 27, 343), - Trans(96, 98, 27, 343), - Trans(96, 99, 27, 343), - Trans(96, 103, 27, 343), - Trans(96, 105, 27, 343), - Trans(96, 108, 27, 343), - Trans(96, 109, 27, 343), - Trans(96, 110, 27, 343), - Trans(96, 111, 27, 343), - Trans(97, 5, 27, 343), - Trans(97, 6, 27, 343), - Trans(97, 7, 27, 343), - Trans(97, 8, 27, 343), - Trans(97, 9, 27, 343), - Trans(97, 10, 27, 343), - Trans(97, 11, 27, 343), - Trans(97, 18, 27, 343), - Trans(97, 24, 27, 343), - Trans(97, 25, 27, 343), - Trans(97, 26, 27, 343), - Trans(97, 27, 27, 343), - Trans(97, 35, 27, 343), - Trans(97, 37, 27, 343), - Trans(97, 38, 27, 343), - Trans(97, 40, 27, 343), - Trans(97, 44, 27, 343), - Trans(97, 52, 27, 343), - Trans(97, 69, 27, 343), - Trans(97, 75, 27, 343), - Trans(97, 82, 27, 343), - Trans(97, 85, 27, 343), - Trans(97, 87, 27, 343), - Trans(97, 110, 27, 343), - Trans(97, 111, 27, 343), - Trans(98, 5, 27, 343), - Trans(98, 12, 27, 343), - Trans(98, 14, 27, 343), - Trans(98, 16, 27, 343), - Trans(98, 17, 27, 343), - Trans(98, 18, 27, 343), - Trans(98, 19, 27, 343), - Trans(98, 20, 27, 343), - Trans(98, 21, 27, 343), - Trans(98, 22, 27, 343), - Trans(98, 23, 27, 343), - Trans(98, 24, 27, 343), - Trans(98, 25, 27, 343), - Trans(98, 26, 27, 343), - Trans(98, 29, 27, 343), - Trans(98, 30, 27, 343), - Trans(98, 31, 27, 343), - Trans(98, 32, 27, 343), - Trans(98, 35, 27, 343), - Trans(98, 38, 27, 343), - Trans(98, 41, 27, 343), - Trans(98, 42, 27, 343), - Trans(98, 43, 27, 343), - Trans(98, 44, 27, 343), - Trans(98, 45, 27, 343), - Trans(98, 46, 27, 343), - Trans(98, 47, 27, 343), - Trans(98, 48, 27, 343), - Trans(98, 49, 27, 343), - Trans(98, 50, 27, 343), - Trans(98, 57, 27, 343), - Trans(98, 59, 27, 343), - Trans(98, 60, 27, 343), - Trans(98, 63, 27, 343), - Trans(98, 64, 27, 343), - Trans(98, 65, 27, 343), - Trans(98, 69, 27, 343), - Trans(98, 70, 27, 343), - Trans(98, 72, 27, 343), - Trans(98, 76, 27, 343), - Trans(98, 79, 27, 343), - Trans(98, 80, 27, 343), - Trans(98, 83, 27, 343), - Trans(98, 92, 27, 343), - Trans(98, 101, 27, 343), - Trans(98, 103, 27, 343), - Trans(98, 105, 27, 343), - Trans(98, 108, 27, 343), - Trans(98, 109, 27, 343), - Trans(99, 12, 27, 343), - Trans(99, 13, 27, 343), - Trans(99, 14, 27, 343), - Trans(99, 16, 27, 343), - Trans(99, 17, 27, 343), - Trans(99, 18, 27, 343), - Trans(99, 19, 27, 343), - Trans(99, 20, 27, 343), - Trans(99, 21, 27, 343), - Trans(99, 22, 27, 343), - Trans(99, 23, 27, 343), - Trans(99, 24, 27, 343), - Trans(99, 25, 27, 343), - Trans(99, 26, 27, 343), - Trans(99, 29, 27, 343), - Trans(99, 30, 27, 343), - Trans(99, 31, 27, 343), - Trans(99, 32, 27, 343), - Trans(99, 38, 27, 343), - Trans(99, 40, 27, 343), - Trans(99, 41, 27, 343), - Trans(99, 42, 27, 343), - Trans(99, 43, 27, 343), - Trans(99, 44, 27, 343), - Trans(99, 45, 27, 343), - Trans(99, 46, 27, 343), - Trans(99, 50, 27, 343), - Trans(99, 92, 27, 343), - Trans(99, 101, 27, 343), - Trans(100, 5, 27, 343), - Trans(100, 51, 27, 343), - Trans(100, 53, 27, 343), - Trans(100, 54, 27, 343), - Trans(100, 55, 27, 343), - Trans(100, 61, 27, 343), - Trans(100, 62, 27, 343), - Trans(100, 66, 27, 343), - Trans(100, 67, 27, 343), - Trans(100, 81, 27, 343), - Trans(100, 93, 27, 343), - Trans(100, 94, 27, 343), - Trans(100, 95, 27, 343), - Trans(100, 96, 27, 343), - Trans(100, 97, 27, 343), - Trans(100, 100, 27, 343), - Trans(100, 102, 27, 343), - Trans(100, 104, 27, 343), - Trans(100, 106, 27, 343), - Trans(100, 107, 27, 343), - Trans(100, 110, 27, 343), - Trans(100, 111, 27, 343), - Trans(101, 5, 27, 343), - Trans(101, 35, 27, 343), - Trans(101, 38, 27, 343), - Trans(101, 44, 27, 343), - Trans(101, 111, 27, 343), - Trans(102, 5, 27, 343), - Trans(102, 12, 27, 343), - Trans(102, 14, 27, 343), - Trans(102, 16, 27, 343), - Trans(102, 17, 27, 343), - Trans(102, 18, 27, 343), - Trans(102, 19, 27, 343), - Trans(102, 20, 27, 343), - Trans(102, 21, 27, 343), - Trans(102, 22, 27, 343), - Trans(102, 23, 27, 343), - Trans(102, 24, 27, 343), - Trans(102, 25, 27, 343), - Trans(102, 26, 27, 343), - Trans(102, 29, 27, 343), - Trans(102, 30, 27, 343), - Trans(102, 31, 27, 343), - Trans(102, 32, 27, 343), - Trans(102, 38, 27, 343), - Trans(102, 40, 27, 343), - Trans(102, 41, 27, 343), - Trans(102, 42, 27, 343), - Trans(102, 43, 27, 343), - Trans(102, 44, 27, 343), - Trans(102, 45, 27, 343), - Trans(102, 46, 27, 343), - Trans(102, 50, 27, 343), - Trans(102, 92, 27, 343), - Trans(102, 101, 27, 343), - Trans(103, 30, 27, 343), - Trans(103, 34, 27, 343), - Trans(103, 38, 27, 343), - Trans(103, 39, 27, 343), - Trans(103, 42, 27, 343), - Trans(103, 44, 27, 343), - Trans(103, 45, 27, 343), - Trans(103, 78, 27, 343), - Trans(104, 5, 27, 343), - Trans(104, 35, 27, 343), - Trans(104, 38, 27, 343), - Trans(104, 42, 27, 343), - Trans(104, 44, 27, 343), - Trans(104, 80, 27, 343), - Trans(104, 89, 27, 343), - Trans(104, 111, 27, 343), - Trans(105, 5, 27, 343), - Trans(105, 35, 27, 343), - Trans(105, 38, 27, 343), - Trans(105, 42, 27, 343), - Trans(105, 52, 27, 343), - Trans(105, 64, 27, 343), - Trans(105, 68, 27, 343), - Trans(105, 69, 27, 343), - Trans(105, 79, 27, 343), - Trans(105, 98, 27, 343), - Trans(105, 99, 27, 343), - Trans(105, 109, 27, 343), - Trans(105, 110, 27, 343), - Trans(105, 111, 27, 343), - Trans(106, 5, 27, 343), - Trans(106, 29, 27, 343), - Trans(106, 30, 27, 343), - Trans(106, 35, 27, 343), - Trans(106, 38, 27, 343), - Trans(106, 42, 27, 343), - Trans(106, 44, 27, 343), - Trans(106, 47, 27, 343), - Trans(106, 48, 27, 343), - Trans(106, 49, 27, 343), - Trans(106, 59, 27, 343), - Trans(106, 60, 27, 343), - Trans(106, 63, 27, 343), - Trans(106, 64, 27, 343), - Trans(106, 65, 27, 343), - Trans(106, 69, 27, 343), - Trans(106, 70, 27, 343), - Trans(106, 72, 27, 343), - Trans(106, 76, 27, 343), - Trans(106, 79, 27, 343), - Trans(106, 80, 27, 343), - Trans(106, 83, 27, 343), - Trans(106, 103, 27, 343), - Trans(106, 105, 27, 343), - Trans(106, 108, 27, 343), - Trans(106, 109, 27, 343), - Trans(107, 5, 27, 343), - Trans(107, 13, 27, 343), - Trans(107, 38, 27, 343), - Trans(107, 40, 27, 343), - Trans(108, 5, 27, 343), - Trans(108, 29, 27, 343), - Trans(108, 35, 27, 343), - Trans(108, 38, 27, 343), - Trans(108, 42, 27, 343), - Trans(108, 47, 27, 343), - Trans(108, 48, 27, 343), - Trans(108, 49, 27, 343), - Trans(108, 52, 27, 343), - Trans(108, 59, 27, 343), - Trans(108, 60, 27, 343), - Trans(108, 63, 27, 343), - Trans(108, 64, 27, 343), - Trans(108, 65, 27, 343), - Trans(108, 68, 27, 343), - Trans(108, 69, 27, 343), - Trans(108, 70, 27, 343), - Trans(108, 72, 27, 343), - Trans(108, 76, 27, 343), - Trans(108, 79, 27, 343), - Trans(108, 80, 27, 343), - Trans(108, 83, 27, 343), - Trans(108, 98, 27, 343), - Trans(108, 99, 27, 343), - Trans(108, 103, 27, 343), - Trans(108, 105, 27, 343), - Trans(108, 108, 27, 343), - Trans(108, 109, 27, 343), - Trans(108, 110, 27, 343), - Trans(108, 111, 27, 343), - Trans(109, 40, 27, 343), - Trans(110, 110, 27, 343), - Trans(110, 111, 27, 343), - Trans(111, 5, 27, 343), - Trans(111, 12, 27, 343), - Trans(111, 14, 27, 343), - Trans(111, 16, 27, 343), - Trans(111, 17, 27, 343), - Trans(111, 18, 27, 343), - Trans(111, 19, 27, 343), - Trans(111, 20, 27, 343), - Trans(111, 21, 27, 343), - Trans(111, 22, 27, 343), - Trans(111, 23, 27, 343), - Trans(111, 24, 27, 343), - Trans(111, 25, 27, 343), - Trans(111, 26, 27, 343), - Trans(111, 28, 27, 343), - Trans(111, 29, 27, 343), - Trans(111, 30, 27, 343), - Trans(111, 31, 27, 343), - Trans(111, 32, 27, 343), - Trans(111, 38, 27, 343), - Trans(111, 41, 27, 343), - Trans(111, 42, 27, 343), - Trans(111, 43, 27, 343), - Trans(111, 44, 27, 343), - Trans(111, 45, 27, 343), - Trans(111, 46, 27, 343), - Trans(111, 50, 27, 343), - Trans(111, 92, 27, 343), - Trans(111, 101, 27, 343), - Trans(112, 111, 27, 343), - Trans(113, 5, 27, 343), - Trans(113, 12, 27, 343), - Trans(113, 14, 27, 343), - Trans(113, 15, 27, 343), - Trans(113, 16, 27, 343), - Trans(113, 17, 27, 343), - Trans(113, 18, 27, 343), - Trans(113, 19, 27, 343), - Trans(113, 20, 27, 343), - Trans(113, 21, 27, 343), - Trans(113, 22, 27, 343), - Trans(113, 23, 27, 343), - Trans(113, 24, 27, 343), - Trans(113, 25, 27, 343), - Trans(113, 26, 27, 343), - Trans(113, 29, 27, 343), - Trans(113, 30, 27, 343), - Trans(113, 31, 27, 343), - Trans(113, 32, 27, 343), - Trans(113, 33, 27, 343), - Trans(113, 34, 27, 343), - Trans(113, 38, 27, 343), - Trans(113, 39, 27, 343), - Trans(113, 40, 27, 343), - Trans(113, 41, 27, 343), - Trans(113, 42, 27, 343), - Trans(113, 43, 27, 343), - Trans(113, 44, 27, 343), - Trans(113, 45, 27, 343), - Trans(113, 46, 27, 343), - Trans(113, 50, 27, 343), - Trans(113, 92, 27, 343), - Trans(113, 101, 27, 343), + Trans(26, 38, 33, -1), + Trans(26, 39, 30, -1), + Trans(26, 41, 30, -1), + Trans(26, 53, 30, -1), + Trans(26, 70, 30, -1), + Trans(26, 76, 30, -1), + Trans(26, 83, 64, -1), + Trans(26, 86, 64, -1), + Trans(26, 88, 30, -1), + Trans(26, 111, 65, -1), + Trans(26, 112, 66, -1), + Trans(28, 0, 27, 346), + Trans(28, 6, 27, 346), + Trans(28, 7, 27, 346), + Trans(28, 8, 27, 346), + Trans(28, 9, 27, 346), + Trans(28, 10, 27, 346), + Trans(28, 11, 27, 346), + Trans(28, 18, 27, 346), + Trans(28, 24, 27, 346), + Trans(28, 25, 27, 346), + Trans(28, 26, 27, 346), + Trans(28, 27, 27, 346), + Trans(28, 30, 27, 346), + Trans(28, 36, 27, 346), + Trans(28, 38, 27, 346), + Trans(28, 39, 27, 346), + Trans(28, 41, 27, 346), + Trans(28, 43, 27, 346), + Trans(28, 48, 27, 346), + Trans(28, 49, 27, 346), + Trans(28, 50, 27, 346), + Trans(28, 53, 27, 346), + Trans(28, 57, 27, 346), + Trans(28, 59, 27, 346), + Trans(28, 60, 27, 346), + Trans(28, 61, 27, 346), + Trans(28, 64, 27, 346), + Trans(28, 65, 27, 346), + Trans(28, 66, 27, 346), + Trans(28, 69, 27, 346), + Trans(28, 70, 27, 346), + Trans(28, 71, 27, 346), + Trans(28, 72, 27, 346), + Trans(28, 73, 27, 346), + Trans(28, 76, 27, 346), + Trans(28, 77, 27, 346), + Trans(28, 78, 27, 346), + Trans(28, 80, 27, 346), + Trans(28, 81, 27, 346), + Trans(28, 83, 27, 346), + Trans(28, 84, 27, 346), + Trans(28, 85, 27, 346), + Trans(28, 86, 27, 346), + Trans(28, 88, 27, 346), + Trans(28, 89, 27, 346), + Trans(28, 91, 27, 346), + Trans(28, 99, 27, 346), + Trans(28, 100, 27, 346), + Trans(28, 104, 27, 346), + Trans(28, 106, 27, 346), + Trans(28, 109, 27, 346), + Trans(28, 110, 27, 346), + Trans(28, 111, 27, 346), + Trans(28, 112, 27, 346), + Trans(29, 5, 27, 346), + Trans(29, 16, 27, 346), + Trans(29, 17, 27, 346), + Trans(29, 18, 27, 346), + Trans(29, 19, 27, 346), + Trans(29, 20, 27, 346), + Trans(29, 21, 27, 346), + Trans(29, 22, 27, 346), + Trans(29, 23, 27, 346), + Trans(29, 24, 27, 346), + Trans(29, 25, 27, 346), + Trans(29, 26, 27, 346), + Trans(29, 30, 27, 346), + Trans(29, 31, 27, 346), + Trans(29, 47, 27, 346), + Trans(29, 51, 27, 346), + Trans(30, 5, 27, 346), + Trans(30, 6, 27, 346), + Trans(30, 7, 27, 346), + Trans(30, 8, 27, 346), + Trans(30, 9, 27, 346), + Trans(30, 10, 27, 346), + Trans(30, 11, 27, 346), + Trans(30, 18, 27, 346), + Trans(30, 24, 27, 346), + Trans(30, 25, 27, 346), + Trans(30, 26, 27, 346), + Trans(30, 27, 27, 346), + Trans(30, 38, 27, 346), + Trans(30, 39, 27, 346), + Trans(30, 41, 27, 346), + Trans(30, 53, 27, 346), + Trans(30, 70, 27, 346), + Trans(30, 76, 27, 346), + Trans(30, 83, 27, 346), + Trans(30, 86, 27, 346), + Trans(30, 88, 27, 346), + Trans(30, 111, 27, 346), + Trans(30, 112, 27, 346), + Trans(31, 5, 27, 346), + Trans(31, 112, 27, 346), + Trans(32, 5, 27, 346), + Trans(32, 40, 27, 346), + Trans(33, 5, 27, 346), + Trans(33, 6, 27, 346), + Trans(33, 7, 27, 346), + Trans(33, 8, 27, 346), + Trans(33, 9, 27, 346), + Trans(33, 10, 27, 346), + Trans(33, 11, 27, 346), + Trans(33, 18, 27, 346), + Trans(33, 24, 27, 346), + Trans(33, 25, 27, 346), + Trans(33, 26, 27, 346), + Trans(33, 27, 27, 346), + Trans(33, 38, 27, 346), + Trans(33, 39, 27, 346), + Trans(33, 41, 27, 346), + Trans(33, 53, 27, 346), + Trans(33, 57, 27, 346), + Trans(33, 70, 27, 346), + Trans(33, 76, 27, 346), + Trans(33, 83, 27, 346), + Trans(33, 86, 27, 346), + Trans(33, 88, 27, 346), + Trans(33, 111, 27, 346), + Trans(33, 112, 27, 346), + Trans(34, 5, 27, 346), + Trans(34, 6, 27, 346), + Trans(34, 7, 27, 346), + Trans(34, 8, 27, 346), + Trans(34, 9, 27, 346), + Trans(34, 10, 27, 346), + Trans(34, 11, 27, 346), + Trans(34, 18, 27, 346), + Trans(34, 24, 27, 346), + Trans(34, 25, 27, 346), + Trans(34, 26, 27, 346), + Trans(34, 27, 27, 346), + Trans(34, 30, 27, 346), + Trans(34, 36, 27, 346), + Trans(34, 38, 27, 346), + Trans(34, 39, 27, 346), + Trans(34, 41, 27, 346), + Trans(34, 43, 27, 346), + Trans(34, 48, 27, 346), + Trans(34, 49, 27, 346), + Trans(34, 50, 27, 346), + Trans(34, 53, 27, 346), + Trans(34, 59, 27, 346), + Trans(34, 60, 27, 346), + Trans(34, 61, 27, 346), + Trans(34, 64, 27, 346), + Trans(34, 65, 27, 346), + Trans(34, 66, 27, 346), + Trans(34, 70, 27, 346), + Trans(34, 71, 27, 346), + Trans(34, 72, 27, 346), + Trans(34, 73, 27, 346), + Trans(34, 76, 27, 346), + Trans(34, 77, 27, 346), + Trans(34, 78, 27, 346), + Trans(34, 80, 27, 346), + Trans(34, 81, 27, 346), + Trans(34, 83, 27, 346), + Trans(34, 84, 27, 346), + Trans(34, 85, 27, 346), + Trans(34, 86, 27, 346), + Trans(34, 88, 27, 346), + Trans(34, 89, 27, 346), + Trans(34, 91, 27, 346), + Trans(34, 104, 27, 346), + Trans(34, 106, 27, 346), + Trans(34, 109, 27, 346), + Trans(34, 110, 27, 346), + Trans(34, 111, 27, 346), + Trans(34, 112, 27, 346), + Trans(35, 0, 27, 346), + Trans(35, 5, 27, 346), + Trans(35, 6, 27, 346), + Trans(35, 7, 27, 346), + Trans(35, 8, 27, 346), + Trans(35, 9, 27, 346), + Trans(35, 10, 27, 346), + Trans(35, 11, 27, 346), + Trans(35, 18, 27, 346), + Trans(35, 24, 27, 346), + Trans(35, 25, 27, 346), + Trans(35, 26, 27, 346), + Trans(35, 27, 27, 346), + Trans(35, 30, 27, 346), + Trans(35, 36, 27, 346), + Trans(35, 38, 27, 346), + Trans(35, 39, 27, 346), + Trans(35, 41, 27, 346), + Trans(35, 43, 27, 346), + Trans(35, 48, 27, 346), + Trans(35, 49, 27, 346), + Trans(35, 50, 27, 346), + Trans(35, 53, 27, 346), + Trans(35, 57, 27, 346), + Trans(35, 58, 27, 346), + Trans(35, 59, 27, 346), + Trans(35, 60, 27, 346), + Trans(35, 61, 27, 346), + Trans(35, 64, 27, 346), + Trans(35, 65, 27, 346), + Trans(35, 66, 27, 346), + Trans(35, 69, 27, 346), + Trans(35, 70, 27, 346), + Trans(35, 71, 27, 346), + Trans(35, 72, 27, 346), + Trans(35, 73, 27, 346), + Trans(35, 76, 27, 346), + Trans(35, 77, 27, 346), + Trans(35, 78, 27, 346), + Trans(35, 80, 27, 346), + Trans(35, 81, 27, 346), + Trans(35, 83, 27, 346), + Trans(35, 84, 27, 346), + Trans(35, 85, 27, 346), + Trans(35, 86, 27, 346), + Trans(35, 88, 27, 346), + Trans(35, 89, 27, 346), + Trans(35, 91, 27, 346), + Trans(35, 99, 27, 346), + Trans(35, 100, 27, 346), + Trans(35, 104, 27, 346), + Trans(35, 106, 27, 346), + Trans(35, 109, 27, 346), + Trans(35, 110, 27, 346), + Trans(35, 111, 27, 346), + Trans(35, 112, 27, 346), + Trans(36, 5, 27, 346), + Trans(36, 39, 27, 346), + Trans(37, 5, 27, 346), + Trans(37, 41, 27, 346), + Trans(38, 5, 27, 346), + Trans(38, 30, 27, 346), + Trans(39, 5, 27, 346), + Trans(39, 47, 27, 346), + Trans(39, 111, 27, 346), + Trans(39, 112, 27, 346), + Trans(40, 5, 27, 346), + Trans(40, 111, 27, 346), + Trans(40, 112, 27, 346), + Trans(41, 5, 27, 346), + Trans(41, 78, 27, 346), + Trans(41, 85, 27, 346), + Trans(41, 89, 27, 346), + Trans(42, 5, 27, 346), + Trans(42, 46, 27, 346), + Trans(43, 5, 27, 346), + Trans(43, 15, 27, 346), + Trans(43, 16, 27, 346), + Trans(43, 17, 27, 346), + Trans(43, 18, 27, 346), + Trans(43, 19, 27, 346), + Trans(43, 20, 27, 346), + Trans(43, 21, 27, 346), + Trans(43, 22, 27, 346), + Trans(43, 23, 27, 346), + Trans(43, 24, 27, 346), + Trans(43, 25, 27, 346), + Trans(43, 26, 27, 346), + Trans(43, 29, 27, 346), + Trans(43, 30, 27, 346), + Trans(43, 31, 27, 346), + Trans(43, 34, 27, 346), + Trans(43, 35, 27, 346), + Trans(43, 40, 27, 346), + Trans(43, 41, 27, 346), + Trans(43, 47, 27, 346), + Trans(43, 51, 27, 346), + Trans(44, 5, 27, 346), + Trans(44, 15, 27, 346), + Trans(44, 16, 27, 346), + Trans(44, 17, 27, 346), + Trans(44, 18, 27, 346), + Trans(44, 19, 27, 346), + Trans(44, 20, 27, 346), + Trans(44, 21, 27, 346), + Trans(44, 22, 27, 346), + Trans(44, 23, 27, 346), + Trans(44, 24, 27, 346), + Trans(44, 25, 27, 346), + Trans(44, 26, 27, 346), + Trans(44, 28, 27, 346), + Trans(44, 29, 27, 346), + Trans(44, 30, 27, 346), + Trans(44, 31, 27, 346), + Trans(44, 34, 27, 346), + Trans(44, 35, 27, 346), + Trans(44, 40, 27, 346), + Trans(44, 41, 27, 346), + Trans(44, 47, 27, 346), + Trans(44, 51, 27, 346), + Trans(45, 12, 27, 346), + Trans(45, 14, 27, 346), + Trans(45, 16, 27, 346), + Trans(45, 17, 27, 346), + Trans(45, 18, 27, 346), + Trans(45, 19, 27, 346), + Trans(45, 20, 27, 346), + Trans(45, 21, 27, 346), + Trans(45, 22, 27, 346), + Trans(45, 23, 27, 346), + Trans(45, 24, 27, 346), + Trans(45, 25, 27, 346), + Trans(45, 26, 27, 346), + Trans(45, 30, 27, 346), + Trans(45, 31, 27, 346), + Trans(45, 32, 27, 346), + Trans(45, 33, 27, 346), + Trans(45, 36, 27, 346), + Trans(45, 39, 27, 346), + Trans(45, 42, 27, 346), + Trans(45, 43, 27, 346), + Trans(45, 44, 27, 346), + Trans(45, 45, 27, 346), + Trans(45, 46, 27, 346), + Trans(45, 47, 27, 346), + Trans(45, 48, 27, 346), + Trans(45, 49, 27, 346), + Trans(45, 50, 27, 346), + Trans(45, 51, 27, 346), + Trans(45, 58, 27, 346), + Trans(45, 60, 27, 346), + Trans(45, 61, 27, 346), + Trans(45, 64, 27, 346), + Trans(45, 65, 27, 346), + Trans(45, 66, 27, 346), + Trans(45, 70, 27, 346), + Trans(45, 71, 27, 346), + Trans(45, 73, 27, 346), + Trans(45, 77, 27, 346), + Trans(45, 80, 27, 346), + Trans(45, 81, 27, 346), + Trans(45, 84, 27, 346), + Trans(45, 93, 27, 346), + Trans(45, 102, 27, 346), + Trans(45, 104, 27, 346), + Trans(45, 106, 27, 346), + Trans(45, 109, 27, 346), + Trans(45, 110, 27, 346), + Trans(46, 5, 27, 346), + Trans(46, 6, 27, 346), + Trans(46, 7, 27, 346), + Trans(46, 8, 27, 346), + Trans(46, 9, 27, 346), + Trans(46, 10, 27, 346), + Trans(46, 11, 27, 346), + Trans(46, 18, 27, 346), + Trans(46, 24, 27, 346), + Trans(46, 25, 27, 346), + Trans(46, 26, 27, 346), + Trans(46, 27, 27, 346), + Trans(46, 38, 27, 346), + Trans(46, 39, 27, 346), + Trans(46, 41, 27, 346), + Trans(46, 53, 27, 346), + Trans(46, 65, 27, 346), + Trans(46, 69, 27, 346), + Trans(46, 70, 27, 346), + Trans(46, 76, 27, 346), + Trans(46, 80, 27, 346), + Trans(46, 83, 27, 346), + Trans(46, 86, 27, 346), + Trans(46, 88, 27, 346), + Trans(46, 99, 27, 346), + Trans(46, 100, 27, 346), + Trans(46, 111, 27, 346), + Trans(46, 112, 27, 346), + Trans(47, 5, 27, 346), + Trans(47, 6, 27, 346), + Trans(47, 7, 27, 346), + Trans(47, 8, 27, 346), + Trans(47, 9, 27, 346), + Trans(47, 10, 27, 346), + Trans(47, 11, 27, 346), + Trans(47, 18, 27, 346), + Trans(47, 24, 27, 346), + Trans(47, 25, 27, 346), + Trans(47, 26, 27, 346), + Trans(47, 27, 27, 346), + Trans(47, 36, 27, 346), + Trans(47, 38, 27, 346), + Trans(47, 39, 27, 346), + Trans(47, 41, 27, 346), + Trans(47, 43, 27, 346), + Trans(47, 45, 27, 346), + Trans(47, 53, 27, 346), + Trans(47, 57, 27, 346), + Trans(47, 70, 27, 346), + Trans(47, 76, 27, 346), + Trans(47, 81, 27, 346), + Trans(47, 83, 27, 346), + Trans(47, 86, 27, 346), + Trans(47, 88, 27, 346), + Trans(47, 90, 27, 346), + Trans(47, 111, 27, 346), + Trans(47, 112, 27, 346), + Trans(48, 5, 27, 346), + Trans(48, 6, 27, 346), + Trans(48, 7, 27, 346), + Trans(48, 8, 27, 346), + Trans(48, 9, 27, 346), + Trans(48, 10, 27, 346), + Trans(48, 11, 27, 346), + Trans(48, 18, 27, 346), + Trans(48, 24, 27, 346), + Trans(48, 25, 27, 346), + Trans(48, 26, 27, 346), + Trans(48, 27, 27, 346), + Trans(48, 30, 27, 346), + Trans(48, 36, 27, 346), + Trans(48, 38, 27, 346), + Trans(48, 39, 27, 346), + Trans(48, 41, 27, 346), + Trans(48, 43, 27, 346), + Trans(48, 48, 27, 346), + Trans(48, 49, 27, 346), + Trans(48, 50, 27, 346), + Trans(48, 53, 27, 346), + Trans(48, 57, 27, 346), + Trans(48, 60, 27, 346), + Trans(48, 61, 27, 346), + Trans(48, 64, 27, 346), + Trans(48, 65, 27, 346), + Trans(48, 66, 27, 346), + Trans(48, 69, 27, 346), + Trans(48, 70, 27, 346), + Trans(48, 71, 27, 346), + Trans(48, 73, 27, 346), + Trans(48, 76, 27, 346), + Trans(48, 77, 27, 346), + Trans(48, 80, 27, 346), + Trans(48, 81, 27, 346), + Trans(48, 83, 27, 346), + Trans(48, 84, 27, 346), + Trans(48, 86, 27, 346), + Trans(48, 88, 27, 346), + Trans(48, 99, 27, 346), + Trans(48, 100, 27, 346), + Trans(48, 104, 27, 346), + Trans(48, 106, 27, 346), + Trans(48, 109, 27, 346), + Trans(48, 110, 27, 346), + Trans(48, 111, 27, 346), + Trans(48, 112, 27, 346), + Trans(49, 5, 27, 346), + Trans(49, 31, 27, 346), + Trans(49, 35, 27, 346), + Trans(49, 39, 27, 346), + Trans(49, 40, 27, 346), + Trans(49, 43, 27, 346), + Trans(49, 45, 27, 346), + Trans(49, 46, 27, 346), + Trans(49, 79, 27, 346), + Trans(50, 0, 27, 346), + Trans(50, 5, 27, 346), + Trans(50, 12, 27, 346), + Trans(50, 14, 27, 346), + Trans(50, 16, 27, 346), + Trans(50, 17, 27, 346), + Trans(50, 18, 27, 346), + Trans(50, 19, 27, 346), + Trans(50, 20, 27, 346), + Trans(50, 21, 27, 346), + Trans(50, 22, 27, 346), + Trans(50, 23, 27, 346), + Trans(50, 24, 27, 346), + Trans(50, 25, 27, 346), + Trans(50, 26, 27, 346), + Trans(50, 30, 27, 346), + Trans(50, 31, 27, 346), + Trans(50, 32, 27, 346), + Trans(50, 33, 27, 346), + Trans(50, 36, 27, 346), + Trans(50, 39, 27, 346), + Trans(50, 42, 27, 346), + Trans(50, 43, 27, 346), + Trans(50, 44, 27, 346), + Trans(50, 45, 27, 346), + Trans(50, 46, 27, 346), + Trans(50, 47, 27, 346), + Trans(50, 48, 27, 346), + Trans(50, 49, 27, 346), + Trans(50, 50, 27, 346), + Trans(50, 51, 27, 346), + Trans(50, 58, 27, 346), + Trans(50, 59, 27, 346), + Trans(50, 60, 27, 346), + Trans(50, 61, 27, 346), + Trans(50, 64, 27, 346), + Trans(50, 65, 27, 346), + Trans(50, 66, 27, 346), + Trans(50, 70, 27, 346), + Trans(50, 71, 27, 346), + Trans(50, 72, 27, 346), + Trans(50, 73, 27, 346), + Trans(50, 77, 27, 346), + Trans(50, 78, 27, 346), + Trans(50, 80, 27, 346), + Trans(50, 81, 27, 346), + Trans(50, 84, 27, 346), + Trans(50, 85, 27, 346), + Trans(50, 89, 27, 346), + Trans(50, 91, 27, 346), + Trans(50, 93, 27, 346), + Trans(50, 102, 27, 346), + Trans(50, 104, 27, 346), + Trans(50, 106, 27, 346), + Trans(50, 109, 27, 346), + Trans(50, 110, 27, 346), + Trans(51, 5, 27, 346), + Trans(51, 12, 27, 346), + Trans(51, 14, 27, 346), + Trans(51, 15, 27, 346), + Trans(51, 16, 27, 346), + Trans(51, 17, 27, 346), + Trans(51, 18, 27, 346), + Trans(51, 19, 27, 346), + Trans(51, 20, 27, 346), + Trans(51, 21, 27, 346), + Trans(51, 22, 27, 346), + Trans(51, 23, 27, 346), + Trans(51, 24, 27, 346), + Trans(51, 25, 27, 346), + Trans(51, 26, 27, 346), + Trans(51, 30, 27, 346), + Trans(51, 31, 27, 346), + Trans(51, 32, 27, 346), + Trans(51, 33, 27, 346), + Trans(51, 34, 27, 346), + Trans(51, 35, 27, 346), + Trans(51, 36, 27, 346), + Trans(51, 39, 27, 346), + Trans(51, 40, 27, 346), + Trans(51, 41, 27, 346), + Trans(51, 42, 27, 346), + Trans(51, 43, 27, 346), + Trans(51, 44, 27, 346), + Trans(51, 45, 27, 346), + Trans(51, 46, 27, 346), + Trans(51, 47, 27, 346), + Trans(51, 51, 27, 346), + Trans(51, 93, 27, 346), + Trans(51, 102, 27, 346), + Trans(52, 5, 27, 346), + Trans(52, 12, 27, 346), + Trans(52, 13, 27, 346), + Trans(52, 14, 27, 346), + Trans(52, 16, 27, 346), + Trans(52, 17, 27, 346), + Trans(52, 18, 27, 346), + Trans(52, 19, 27, 346), + Trans(52, 20, 27, 346), + Trans(52, 21, 27, 346), + Trans(52, 22, 27, 346), + Trans(52, 23, 27, 346), + Trans(52, 24, 27, 346), + Trans(52, 25, 27, 346), + Trans(52, 26, 27, 346), + Trans(52, 30, 27, 346), + Trans(52, 31, 27, 346), + Trans(52, 32, 27, 346), + Trans(52, 33, 27, 346), + Trans(52, 39, 27, 346), + Trans(52, 41, 27, 346), + Trans(52, 42, 27, 346), + Trans(52, 43, 27, 346), + Trans(52, 44, 27, 346), + Trans(52, 45, 27, 346), + Trans(52, 46, 27, 346), + Trans(52, 47, 27, 346), + Trans(52, 51, 27, 346), + Trans(52, 93, 27, 346), + Trans(52, 102, 27, 346), + Trans(53, 5, 27, 346), + Trans(53, 39, 27, 346), + Trans(53, 70, 27, 346), + Trans(54, 5, 27, 346), + Trans(54, 6, 27, 346), + Trans(54, 7, 27, 346), + Trans(54, 8, 27, 346), + Trans(54, 9, 27, 346), + Trans(54, 10, 27, 346), + Trans(54, 11, 27, 346), + Trans(54, 15, 27, 346), + Trans(54, 18, 27, 346), + Trans(54, 24, 27, 346), + Trans(54, 25, 27, 346), + Trans(54, 26, 27, 346), + Trans(54, 27, 27, 346), + Trans(54, 38, 27, 346), + Trans(54, 39, 27, 346), + Trans(54, 41, 27, 346), + Trans(54, 53, 27, 346), + Trans(54, 70, 27, 346), + Trans(54, 76, 27, 346), + Trans(54, 83, 27, 346), + Trans(54, 86, 27, 346), + Trans(54, 88, 27, 346), + Trans(54, 111, 27, 346), + Trans(54, 112, 27, 346), + Trans(55, 12, 27, 346), + Trans(55, 14, 27, 346), + Trans(55, 15, 27, 346), + Trans(55, 16, 27, 346), + Trans(55, 17, 27, 346), + Trans(55, 18, 27, 346), + Trans(55, 19, 27, 346), + Trans(55, 20, 27, 346), + Trans(55, 21, 27, 346), + Trans(55, 22, 27, 346), + Trans(55, 23, 27, 346), + Trans(55, 24, 27, 346), + Trans(55, 25, 27, 346), + Trans(55, 26, 27, 346), + Trans(55, 29, 27, 346), + Trans(55, 30, 27, 346), + Trans(55, 31, 27, 346), + Trans(55, 32, 27, 346), + Trans(55, 33, 27, 346), + Trans(55, 34, 27, 346), + Trans(55, 35, 27, 346), + Trans(55, 36, 27, 346), + Trans(55, 37, 27, 346), + Trans(55, 39, 27, 346), + Trans(55, 40, 27, 346), + Trans(55, 41, 27, 346), + Trans(55, 42, 27, 346), + Trans(55, 43, 27, 346), + Trans(55, 44, 27, 346), + Trans(55, 45, 27, 346), + Trans(55, 46, 27, 346), + Trans(55, 47, 27, 346), + Trans(55, 51, 27, 346), + Trans(55, 79, 27, 346), + Trans(55, 93, 27, 346), + Trans(55, 102, 27, 346), + Trans(56, 5, 27, 346), + Trans(56, 47, 27, 346), + Trans(56, 112, 27, 346), + Trans(57, 5, 27, 346), + Trans(57, 6, 27, 346), + Trans(57, 7, 27, 346), + Trans(57, 8, 27, 346), + Trans(57, 9, 27, 346), + Trans(57, 10, 27, 346), + Trans(57, 11, 27, 346), + Trans(57, 18, 27, 346), + Trans(57, 24, 27, 346), + Trans(57, 25, 27, 346), + Trans(57, 26, 27, 346), + Trans(57, 27, 27, 346), + Trans(57, 36, 27, 346), + Trans(57, 38, 27, 346), + Trans(57, 39, 27, 346), + Trans(57, 41, 27, 346), + Trans(57, 42, 27, 346), + Trans(57, 43, 27, 346), + Trans(57, 45, 27, 346), + Trans(57, 53, 27, 346), + Trans(57, 57, 27, 346), + Trans(57, 70, 27, 346), + Trans(57, 76, 27, 346), + Trans(57, 81, 27, 346), + Trans(57, 83, 27, 346), + Trans(57, 86, 27, 346), + Trans(57, 88, 27, 346), + Trans(57, 90, 27, 346), + Trans(57, 111, 27, 346), + Trans(57, 112, 27, 346), + Trans(58, 5, 27, 346), + Trans(58, 6, 27, 346), + Trans(58, 7, 27, 346), + Trans(58, 8, 27, 346), + Trans(58, 9, 27, 346), + Trans(58, 10, 27, 346), + Trans(58, 11, 27, 346), + Trans(58, 18, 27, 346), + Trans(58, 24, 27, 346), + Trans(58, 25, 27, 346), + Trans(58, 26, 27, 346), + Trans(58, 27, 27, 346), + Trans(58, 30, 27, 346), + Trans(58, 36, 27, 346), + Trans(58, 38, 27, 346), + Trans(58, 39, 27, 346), + Trans(58, 41, 27, 346), + Trans(58, 43, 27, 346), + Trans(58, 48, 27, 346), + Trans(58, 49, 27, 346), + Trans(58, 50, 27, 346), + Trans(58, 53, 27, 346), + Trans(58, 57, 27, 346), + Trans(58, 60, 27, 346), + Trans(58, 64, 27, 346), + Trans(58, 65, 27, 346), + Trans(58, 66, 27, 346), + Trans(58, 69, 27, 346), + Trans(58, 70, 27, 346), + Trans(58, 71, 27, 346), + Trans(58, 73, 27, 346), + Trans(58, 76, 27, 346), + Trans(58, 77, 27, 346), + Trans(58, 80, 27, 346), + Trans(58, 81, 27, 346), + Trans(58, 83, 27, 346), + Trans(58, 84, 27, 346), + Trans(58, 86, 27, 346), + Trans(58, 88, 27, 346), + Trans(58, 99, 27, 346), + Trans(58, 100, 27, 346), + Trans(58, 104, 27, 346), + Trans(58, 106, 27, 346), + Trans(58, 109, 27, 346), + Trans(58, 110, 27, 346), + Trans(58, 111, 27, 346), + Trans(58, 112, 27, 346), + Trans(59, 5, 27, 346), + Trans(59, 6, 27, 346), + Trans(59, 7, 27, 346), + Trans(59, 8, 27, 346), + Trans(59, 9, 27, 346), + Trans(59, 10, 27, 346), + Trans(59, 11, 27, 346), + Trans(59, 18, 27, 346), + Trans(59, 24, 27, 346), + Trans(59, 25, 27, 346), + Trans(59, 26, 27, 346), + Trans(59, 27, 27, 346), + Trans(59, 36, 27, 346), + Trans(59, 38, 27, 346), + Trans(59, 39, 27, 346), + Trans(59, 41, 27, 346), + Trans(59, 45, 27, 346), + Trans(59, 53, 27, 346), + Trans(59, 70, 27, 346), + Trans(59, 76, 27, 346), + Trans(59, 83, 27, 346), + Trans(59, 86, 27, 346), + Trans(59, 88, 27, 346), + Trans(59, 111, 27, 346), + Trans(59, 112, 27, 346), + Trans(60, 5, 27, 346), + Trans(60, 12, 27, 346), + Trans(60, 14, 27, 346), + Trans(60, 15, 27, 346), + Trans(60, 16, 27, 346), + Trans(60, 17, 27, 346), + Trans(60, 18, 27, 346), + Trans(60, 19, 27, 346), + Trans(60, 20, 27, 346), + Trans(60, 21, 27, 346), + Trans(60, 22, 27, 346), + Trans(60, 23, 27, 346), + Trans(60, 24, 27, 346), + Trans(60, 25, 27, 346), + Trans(60, 26, 27, 346), + Trans(60, 29, 27, 346), + Trans(60, 30, 27, 346), + Trans(60, 31, 27, 346), + Trans(60, 32, 27, 346), + Trans(60, 33, 27, 346), + Trans(60, 34, 27, 346), + Trans(60, 35, 27, 346), + Trans(60, 36, 27, 346), + Trans(60, 37, 27, 346), + Trans(60, 39, 27, 346), + Trans(60, 40, 27, 346), + Trans(60, 41, 27, 346), + Trans(60, 42, 27, 346), + Trans(60, 43, 27, 346), + Trans(60, 44, 27, 346), + Trans(60, 45, 27, 346), + Trans(60, 46, 27, 346), + Trans(60, 47, 27, 346), + Trans(60, 51, 27, 346), + Trans(60, 79, 27, 346), + Trans(60, 93, 27, 346), + Trans(60, 102, 27, 346), + Trans(61, 5, 27, 346), + Trans(61, 12, 27, 346), + Trans(61, 14, 27, 346), + Trans(61, 16, 27, 346), + Trans(61, 17, 27, 346), + Trans(61, 18, 27, 346), + Trans(61, 19, 27, 346), + Trans(61, 20, 27, 346), + Trans(61, 21, 27, 346), + Trans(61, 22, 27, 346), + Trans(61, 23, 27, 346), + Trans(61, 24, 27, 346), + Trans(61, 25, 27, 346), + Trans(61, 26, 27, 346), + Trans(61, 30, 27, 346), + Trans(61, 31, 27, 346), + Trans(61, 32, 27, 346), + Trans(61, 33, 27, 346), + Trans(61, 36, 27, 346), + Trans(61, 39, 27, 346), + Trans(61, 42, 27, 346), + Trans(61, 43, 27, 346), + Trans(61, 44, 27, 346), + Trans(61, 45, 27, 346), + Trans(61, 46, 27, 346), + Trans(61, 47, 27, 346), + Trans(61, 48, 27, 346), + Trans(61, 49, 27, 346), + Trans(61, 50, 27, 346), + Trans(61, 51, 27, 346), + Trans(61, 58, 27, 346), + Trans(61, 60, 27, 346), + Trans(61, 61, 27, 346), + Trans(61, 64, 27, 346), + Trans(61, 65, 27, 346), + Trans(61, 66, 27, 346), + Trans(61, 70, 27, 346), + Trans(61, 71, 27, 346), + Trans(61, 73, 27, 346), + Trans(61, 77, 27, 346), + Trans(61, 80, 27, 346), + Trans(61, 81, 27, 346), + Trans(61, 84, 27, 346), + Trans(61, 93, 27, 346), + Trans(61, 102, 27, 346), + Trans(61, 104, 27, 346), + Trans(61, 106, 27, 346), + Trans(61, 109, 27, 346), + Trans(61, 110, 27, 346), + Trans(62, 0, 27, 346), + Trans(62, 5, 27, 346), + Trans(62, 6, 27, 346), + Trans(62, 7, 27, 346), + Trans(62, 8, 27, 346), + Trans(62, 9, 27, 346), + Trans(62, 10, 27, 346), + Trans(62, 11, 27, 346), + Trans(62, 18, 27, 346), + Trans(62, 24, 27, 346), + Trans(62, 25, 27, 346), + Trans(62, 26, 27, 346), + Trans(62, 27, 27, 346), + Trans(62, 30, 27, 346), + Trans(62, 36, 27, 346), + Trans(62, 38, 27, 346), + Trans(62, 39, 27, 346), + Trans(62, 41, 27, 346), + Trans(62, 43, 27, 346), + Trans(62, 48, 27, 346), + Trans(62, 49, 27, 346), + Trans(62, 50, 27, 346), + Trans(62, 53, 27, 346), + Trans(62, 57, 27, 346), + Trans(62, 59, 27, 346), + Trans(62, 60, 27, 346), + Trans(62, 61, 27, 346), + Trans(62, 64, 27, 346), + Trans(62, 65, 27, 346), + Trans(62, 66, 27, 346), + Trans(62, 69, 27, 346), + Trans(62, 70, 27, 346), + Trans(62, 71, 27, 346), + Trans(62, 72, 27, 346), + Trans(62, 73, 27, 346), + Trans(62, 76, 27, 346), + Trans(62, 77, 27, 346), + Trans(62, 78, 27, 346), + Trans(62, 80, 27, 346), + Trans(62, 81, 27, 346), + Trans(62, 83, 27, 346), + Trans(62, 84, 27, 346), + Trans(62, 85, 27, 346), + Trans(62, 86, 27, 346), + Trans(62, 88, 27, 346), + Trans(62, 89, 27, 346), + Trans(62, 91, 27, 346), + Trans(62, 99, 27, 346), + Trans(62, 100, 27, 346), + Trans(62, 104, 27, 346), + Trans(62, 106, 27, 346), + Trans(62, 109, 27, 346), + Trans(62, 110, 27, 346), + Trans(62, 111, 27, 346), + Trans(62, 112, 27, 346), + Trans(63, 6, 27, 346), + Trans(63, 7, 27, 346), + Trans(63, 8, 27, 346), + Trans(63, 9, 27, 346), + Trans(63, 10, 27, 346), + Trans(63, 11, 27, 346), + Trans(63, 18, 27, 346), + Trans(63, 24, 27, 346), + Trans(63, 25, 27, 346), + Trans(63, 26, 27, 346), + Trans(63, 27, 27, 346), + Trans(63, 38, 27, 346), + Trans(63, 39, 27, 346), + Trans(63, 41, 27, 346), + Trans(63, 53, 27, 346), + Trans(63, 70, 27, 346), + Trans(63, 76, 27, 346), + Trans(63, 83, 27, 346), + Trans(63, 86, 27, 346), + Trans(63, 88, 27, 346), + Trans(63, 111, 27, 346), + Trans(63, 112, 27, 346), + Trans(64, 5, 27, 346), + Trans(64, 16, 27, 346), + Trans(64, 17, 27, 346), + Trans(64, 18, 27, 346), + Trans(64, 19, 27, 346), + Trans(64, 20, 27, 346), + Trans(64, 21, 27, 346), + Trans(64, 22, 27, 346), + Trans(64, 23, 27, 346), + Trans(64, 24, 27, 346), + Trans(64, 25, 27, 346), + Trans(64, 26, 27, 346), + Trans(64, 44, 27, 346), + Trans(64, 47, 27, 346), + Trans(64, 51, 27, 346), + Trans(65, 5, 27, 346), + Trans(65, 16, 27, 346), + Trans(65, 17, 27, 346), + Trans(65, 18, 27, 346), + Trans(65, 19, 27, 346), + Trans(65, 20, 27, 346), + Trans(65, 21, 27, 346), + Trans(65, 22, 27, 346), + Trans(65, 23, 27, 346), + Trans(65, 24, 27, 346), + Trans(65, 25, 27, 346), + Trans(65, 26, 27, 346), + Trans(65, 29, 27, 346), + Trans(65, 34, 27, 346), + Trans(65, 40, 27, 346), + Trans(65, 41, 27, 346), + Trans(65, 44, 27, 346), + Trans(65, 47, 27, 346), + Trans(65, 51, 27, 346), + Trans(66, 5, 27, 346), + Trans(66, 16, 27, 346), + Trans(66, 17, 27, 346), + Trans(66, 18, 27, 346), + Trans(66, 19, 27, 346), + Trans(66, 20, 27, 346), + Trans(66, 21, 27, 346), + Trans(66, 22, 27, 346), + Trans(66, 23, 27, 346), + Trans(66, 24, 27, 346), + Trans(66, 25, 27, 346), + Trans(66, 26, 27, 346), + Trans(66, 28, 27, 346), + Trans(66, 29, 27, 346), + Trans(66, 34, 27, 346), + Trans(66, 40, 27, 346), + Trans(66, 41, 27, 346), + Trans(66, 44, 27, 346), + Trans(66, 47, 27, 346), + Trans(66, 51, 27, 346), + Trans(67, 5, 27, 346), + Trans(67, 16, 27, 346), + Trans(67, 17, 27, 346), + Trans(67, 18, 27, 346), + Trans(67, 19, 27, 346), + Trans(67, 20, 27, 346), + Trans(67, 21, 27, 346), + Trans(67, 22, 27, 346), + Trans(67, 23, 27, 346), + Trans(67, 24, 27, 346), + Trans(67, 25, 27, 346), + Trans(67, 26, 27, 346), + Trans(67, 46, 27, 346), + Trans(67, 47, 27, 346), + Trans(67, 51, 27, 346), + Trans(68, 5, 27, 346), + Trans(68, 16, 27, 346), + Trans(68, 17, 27, 346), + Trans(68, 18, 27, 346), + Trans(68, 19, 27, 346), + Trans(68, 20, 27, 346), + Trans(68, 21, 27, 346), + Trans(68, 22, 27, 346), + Trans(68, 23, 27, 346), + Trans(68, 24, 27, 346), + Trans(68, 25, 27, 346), + Trans(68, 26, 27, 346), + Trans(68, 29, 27, 346), + Trans(68, 34, 27, 346), + Trans(68, 40, 27, 346), + Trans(68, 41, 27, 346), + Trans(68, 46, 27, 346), + Trans(68, 47, 27, 346), + Trans(68, 51, 27, 346), + Trans(69, 5, 27, 346), + Trans(69, 16, 27, 346), + Trans(69, 17, 27, 346), + Trans(69, 18, 27, 346), + Trans(69, 19, 27, 346), + Trans(69, 20, 27, 346), + Trans(69, 21, 27, 346), + Trans(69, 22, 27, 346), + Trans(69, 23, 27, 346), + Trans(69, 24, 27, 346), + Trans(69, 25, 27, 346), + Trans(69, 26, 27, 346), + Trans(69, 28, 27, 346), + Trans(69, 29, 27, 346), + Trans(69, 34, 27, 346), + Trans(69, 40, 27, 346), + Trans(69, 41, 27, 346), + Trans(69, 46, 27, 346), + Trans(69, 47, 27, 346), + Trans(69, 51, 27, 346), + Trans(70, 5, 27, 346), + Trans(70, 12, 27, 346), + Trans(70, 14, 27, 346), + Trans(70, 16, 27, 346), + Trans(70, 17, 27, 346), + Trans(70, 18, 27, 346), + Trans(70, 19, 27, 346), + Trans(70, 20, 27, 346), + Trans(70, 21, 27, 346), + Trans(70, 22, 27, 346), + Trans(70, 23, 27, 346), + Trans(70, 24, 27, 346), + Trans(70, 25, 27, 346), + Trans(70, 26, 27, 346), + Trans(70, 30, 27, 346), + Trans(70, 31, 27, 346), + Trans(70, 32, 27, 346), + Trans(70, 33, 27, 346), + Trans(70, 39, 27, 346), + Trans(70, 42, 27, 346), + Trans(70, 43, 27, 346), + Trans(70, 44, 27, 346), + Trans(70, 45, 27, 346), + Trans(70, 46, 27, 346), + Trans(70, 47, 27, 346), + Trans(70, 51, 27, 346), + Trans(70, 93, 27, 346), + Trans(70, 102, 27, 346), + Trans(71, 5, 27, 346), + Trans(71, 12, 27, 346), + Trans(71, 14, 27, 346), + Trans(71, 16, 27, 346), + Trans(71, 17, 27, 346), + Trans(71, 18, 27, 346), + Trans(71, 19, 27, 346), + Trans(71, 20, 27, 346), + Trans(71, 21, 27, 346), + Trans(71, 22, 27, 346), + Trans(71, 23, 27, 346), + Trans(71, 24, 27, 346), + Trans(71, 25, 27, 346), + Trans(71, 26, 27, 346), + Trans(71, 29, 27, 346), + Trans(71, 30, 27, 346), + Trans(71, 31, 27, 346), + Trans(71, 32, 27, 346), + Trans(71, 33, 27, 346), + Trans(71, 34, 27, 346), + Trans(71, 39, 27, 346), + Trans(71, 40, 27, 346), + Trans(71, 41, 27, 346), + Trans(71, 42, 27, 346), + Trans(71, 43, 27, 346), + Trans(71, 44, 27, 346), + Trans(71, 45, 27, 346), + Trans(71, 46, 27, 346), + Trans(71, 47, 27, 346), + Trans(71, 51, 27, 346), + Trans(71, 93, 27, 346), + Trans(71, 102, 27, 346), + Trans(72, 5, 27, 346), + Trans(72, 12, 27, 346), + Trans(72, 14, 27, 346), + Trans(72, 16, 27, 346), + Trans(72, 17, 27, 346), + Trans(72, 18, 27, 346), + Trans(72, 19, 27, 346), + Trans(72, 20, 27, 346), + Trans(72, 21, 27, 346), + Trans(72, 22, 27, 346), + Trans(72, 23, 27, 346), + Trans(72, 24, 27, 346), + Trans(72, 25, 27, 346), + Trans(72, 26, 27, 346), + Trans(72, 28, 27, 346), + Trans(72, 29, 27, 346), + Trans(72, 30, 27, 346), + Trans(72, 31, 27, 346), + Trans(72, 32, 27, 346), + Trans(72, 33, 27, 346), + Trans(72, 34, 27, 346), + Trans(72, 39, 27, 346), + Trans(72, 40, 27, 346), + Trans(72, 41, 27, 346), + Trans(72, 42, 27, 346), + Trans(72, 43, 27, 346), + Trans(72, 44, 27, 346), + Trans(72, 45, 27, 346), + Trans(72, 46, 27, 346), + Trans(72, 47, 27, 346), + Trans(72, 51, 27, 346), + Trans(72, 93, 27, 346), + Trans(72, 102, 27, 346), + Trans(73, 6, 27, 346), + Trans(73, 7, 27, 346), + Trans(73, 8, 27, 346), + Trans(73, 9, 27, 346), + Trans(73, 10, 27, 346), + Trans(73, 11, 27, 346), + Trans(73, 18, 27, 346), + Trans(73, 24, 27, 346), + Trans(73, 25, 27, 346), + Trans(73, 26, 27, 346), + Trans(73, 27, 27, 346), + Trans(73, 38, 27, 346), + Trans(73, 39, 27, 346), + Trans(73, 41, 27, 346), + Trans(73, 53, 27, 346), + Trans(73, 65, 27, 346), + Trans(73, 69, 27, 346), + Trans(73, 70, 27, 346), + Trans(73, 76, 27, 346), + Trans(73, 80, 27, 346), + Trans(73, 83, 27, 346), + Trans(73, 86, 27, 346), + Trans(73, 88, 27, 346), + Trans(73, 99, 27, 346), + Trans(73, 100, 27, 346), + Trans(73, 111, 27, 346), + Trans(73, 112, 27, 346), + Trans(74, 5, 27, 346), + Trans(74, 16, 27, 346), + Trans(74, 17, 27, 346), + Trans(74, 18, 27, 346), + Trans(74, 19, 27, 346), + Trans(74, 20, 27, 346), + Trans(74, 21, 27, 346), + Trans(74, 22, 27, 346), + Trans(74, 23, 27, 346), + Trans(74, 24, 27, 346), + Trans(74, 25, 27, 346), + Trans(74, 26, 27, 346), + Trans(74, 31, 27, 346), + Trans(74, 44, 27, 346), + Trans(74, 47, 27, 346), + Trans(74, 51, 27, 346), + Trans(75, 5, 27, 346), + Trans(75, 6, 27, 346), + Trans(75, 7, 27, 346), + Trans(75, 8, 27, 346), + Trans(75, 9, 27, 346), + Trans(75, 10, 27, 346), + Trans(75, 11, 27, 346), + Trans(75, 18, 27, 346), + Trans(75, 24, 27, 346), + Trans(75, 25, 27, 346), + Trans(75, 26, 27, 346), + Trans(75, 27, 27, 346), + Trans(75, 38, 27, 346), + Trans(75, 39, 27, 346), + Trans(75, 41, 27, 346), + Trans(75, 43, 27, 346), + Trans(75, 53, 27, 346), + Trans(75, 65, 27, 346), + Trans(75, 69, 27, 346), + Trans(75, 70, 27, 346), + Trans(75, 76, 27, 346), + Trans(75, 80, 27, 346), + Trans(75, 83, 27, 346), + Trans(75, 86, 27, 346), + Trans(75, 88, 27, 346), + Trans(75, 99, 27, 346), + Trans(75, 100, 27, 346), + Trans(75, 111, 27, 346), + Trans(75, 112, 27, 346), + Trans(76, 5, 27, 346), + Trans(76, 15, 27, 346), + Trans(76, 16, 27, 346), + Trans(76, 17, 27, 346), + Trans(76, 18, 27, 346), + Trans(76, 19, 27, 346), + Trans(76, 20, 27, 346), + Trans(76, 21, 27, 346), + Trans(76, 22, 27, 346), + Trans(76, 23, 27, 346), + Trans(76, 24, 27, 346), + Trans(76, 25, 27, 346), + Trans(76, 26, 27, 346), + Trans(76, 29, 27, 346), + Trans(76, 31, 27, 346), + Trans(76, 34, 27, 346), + Trans(76, 35, 27, 346), + Trans(76, 40, 27, 346), + Trans(76, 41, 27, 346), + Trans(76, 44, 27, 346), + Trans(76, 47, 27, 346), + Trans(76, 51, 27, 346), + Trans(77, 5, 27, 346), + Trans(77, 15, 27, 346), + Trans(77, 16, 27, 346), + Trans(77, 17, 27, 346), + Trans(77, 18, 27, 346), + Trans(77, 19, 27, 346), + Trans(77, 20, 27, 346), + Trans(77, 21, 27, 346), + Trans(77, 22, 27, 346), + Trans(77, 23, 27, 346), + Trans(77, 24, 27, 346), + Trans(77, 25, 27, 346), + Trans(77, 26, 27, 346), + Trans(77, 28, 27, 346), + Trans(77, 29, 27, 346), + Trans(77, 31, 27, 346), + Trans(77, 34, 27, 346), + Trans(77, 35, 27, 346), + Trans(77, 39, 27, 346), + Trans(77, 40, 27, 346), + Trans(77, 41, 27, 346), + Trans(77, 44, 27, 346), + Trans(77, 47, 27, 346), + Trans(77, 51, 27, 346), + Trans(78, 6, 27, 346), + Trans(78, 7, 27, 346), + Trans(78, 8, 27, 346), + Trans(78, 9, 27, 346), + Trans(78, 10, 27, 346), + Trans(78, 11, 27, 346), + Trans(78, 18, 27, 346), + Trans(78, 24, 27, 346), + Trans(78, 25, 27, 346), + Trans(78, 26, 27, 346), + Trans(78, 27, 27, 346), + Trans(78, 36, 27, 346), + Trans(78, 38, 27, 346), + Trans(78, 39, 27, 346), + Trans(78, 41, 27, 346), + Trans(78, 42, 27, 346), + Trans(78, 43, 27, 346), + Trans(78, 45, 27, 346), + Trans(78, 53, 27, 346), + Trans(78, 57, 27, 346), + Trans(78, 70, 27, 346), + Trans(78, 76, 27, 346), + Trans(78, 81, 27, 346), + Trans(78, 83, 27, 346), + Trans(78, 86, 27, 346), + Trans(78, 88, 27, 346), + Trans(78, 90, 27, 346), + Trans(78, 111, 27, 346), + Trans(78, 112, 27, 346), + Trans(79, 5, 27, 346), + Trans(79, 16, 27, 346), + Trans(79, 17, 27, 346), + Trans(79, 18, 27, 346), + Trans(79, 19, 27, 346), + Trans(79, 20, 27, 346), + Trans(79, 21, 27, 346), + Trans(79, 22, 27, 346), + Trans(79, 23, 27, 346), + Trans(79, 24, 27, 346), + Trans(79, 25, 27, 346), + Trans(79, 26, 27, 346), + Trans(79, 30, 27, 346), + Trans(79, 31, 27, 346), + Trans(79, 32, 27, 346), + Trans(79, 33, 27, 346), + Trans(79, 42, 27, 346), + Trans(79, 43, 27, 346), + Trans(79, 44, 27, 346), + Trans(79, 45, 27, 346), + Trans(79, 47, 27, 346), + Trans(79, 51, 27, 346), + Trans(79, 93, 27, 346), + Trans(80, 5, 27, 346), + Trans(80, 6, 27, 346), + Trans(80, 7, 27, 346), + Trans(80, 8, 27, 346), + Trans(80, 9, 27, 346), + Trans(80, 10, 27, 346), + Trans(80, 11, 27, 346), + Trans(80, 18, 27, 346), + Trans(80, 24, 27, 346), + Trans(80, 25, 27, 346), + Trans(80, 26, 27, 346), + Trans(80, 27, 27, 346), + Trans(80, 36, 27, 346), + Trans(80, 38, 27, 346), + Trans(80, 39, 27, 346), + Trans(80, 41, 27, 346), + Trans(80, 53, 27, 346), + Trans(80, 70, 27, 346), + Trans(80, 76, 27, 346), + Trans(80, 81, 27, 346), + Trans(80, 83, 27, 346), + Trans(80, 86, 27, 346), + Trans(80, 88, 27, 346), + Trans(80, 90, 27, 346), + Trans(80, 111, 27, 346), + Trans(80, 112, 27, 346), + Trans(81, 5, 27, 346), + Trans(81, 12, 27, 346), + Trans(81, 14, 27, 346), + Trans(81, 16, 27, 346), + Trans(81, 17, 27, 346), + Trans(81, 18, 27, 346), + Trans(81, 19, 27, 346), + Trans(81, 20, 27, 346), + Trans(81, 21, 27, 346), + Trans(81, 22, 27, 346), + Trans(81, 23, 27, 346), + Trans(81, 24, 27, 346), + Trans(81, 25, 27, 346), + Trans(81, 26, 27, 346), + Trans(81, 30, 27, 346), + Trans(81, 31, 27, 346), + Trans(81, 32, 27, 346), + Trans(81, 33, 27, 346), + Trans(81, 36, 27, 346), + Trans(81, 39, 27, 346), + Trans(81, 42, 27, 346), + Trans(81, 43, 27, 346), + Trans(81, 44, 27, 346), + Trans(81, 45, 27, 346), + Trans(81, 46, 27, 346), + Trans(81, 47, 27, 346), + Trans(81, 48, 27, 346), + Trans(81, 49, 27, 346), + Trans(81, 50, 27, 346), + Trans(81, 51, 27, 346), + Trans(81, 60, 27, 346), + Trans(81, 61, 27, 346), + Trans(81, 64, 27, 346), + Trans(81, 65, 27, 346), + Trans(81, 66, 27, 346), + Trans(81, 70, 27, 346), + Trans(81, 71, 27, 346), + Trans(81, 73, 27, 346), + Trans(81, 77, 27, 346), + Trans(81, 80, 27, 346), + Trans(81, 81, 27, 346), + Trans(81, 84, 27, 346), + Trans(81, 93, 27, 346), + Trans(81, 102, 27, 346), + Trans(81, 104, 27, 346), + Trans(81, 106, 27, 346), + Trans(81, 109, 27, 346), + Trans(81, 110, 27, 346), + Trans(82, 5, 27, 346), + Trans(82, 16, 27, 346), + Trans(82, 17, 27, 346), + Trans(82, 18, 27, 346), + Trans(82, 19, 27, 346), + Trans(82, 20, 27, 346), + Trans(82, 21, 27, 346), + Trans(82, 22, 27, 346), + Trans(82, 23, 27, 346), + Trans(82, 24, 27, 346), + Trans(82, 25, 27, 346), + Trans(82, 26, 27, 346), + Trans(82, 29, 27, 346), + Trans(82, 30, 27, 346), + Trans(82, 31, 27, 346), + Trans(82, 32, 27, 346), + Trans(82, 33, 27, 346), + Trans(82, 34, 27, 346), + Trans(82, 40, 27, 346), + Trans(82, 41, 27, 346), + Trans(82, 42, 27, 346), + Trans(82, 43, 27, 346), + Trans(82, 44, 27, 346), + Trans(82, 45, 27, 346), + Trans(82, 47, 27, 346), + Trans(82, 51, 27, 346), + Trans(82, 93, 27, 346), + Trans(83, 5, 27, 346), + Trans(83, 16, 27, 346), + Trans(83, 17, 27, 346), + Trans(83, 18, 27, 346), + Trans(83, 19, 27, 346), + Trans(83, 20, 27, 346), + Trans(83, 21, 27, 346), + Trans(83, 22, 27, 346), + Trans(83, 23, 27, 346), + Trans(83, 24, 27, 346), + Trans(83, 25, 27, 346), + Trans(83, 26, 27, 346), + Trans(83, 28, 27, 346), + Trans(83, 29, 27, 346), + Trans(83, 30, 27, 346), + Trans(83, 31, 27, 346), + Trans(83, 32, 27, 346), + Trans(83, 33, 27, 346), + Trans(83, 34, 27, 346), + Trans(83, 35, 27, 346), + Trans(83, 40, 27, 346), + Trans(83, 41, 27, 346), + Trans(83, 42, 27, 346), + Trans(83, 43, 27, 346), + Trans(83, 44, 27, 346), + Trans(83, 45, 27, 346), + Trans(83, 47, 27, 346), + Trans(83, 51, 27, 346), + Trans(83, 93, 27, 346), + Trans(84, 5, 27, 346), + Trans(84, 16, 27, 346), + Trans(84, 17, 27, 346), + Trans(84, 18, 27, 346), + Trans(84, 19, 27, 346), + Trans(84, 20, 27, 346), + Trans(84, 21, 27, 346), + Trans(84, 22, 27, 346), + Trans(84, 23, 27, 346), + Trans(84, 24, 27, 346), + Trans(84, 25, 27, 346), + Trans(84, 26, 27, 346), + Trans(84, 30, 27, 346), + Trans(84, 31, 27, 346), + Trans(84, 39, 27, 346), + Trans(84, 43, 27, 346), + Trans(84, 47, 27, 346), + Trans(84, 51, 27, 346), + Trans(84, 102, 27, 346), + Trans(85, 5, 27, 346), + Trans(85, 16, 27, 346), + Trans(85, 17, 27, 346), + Trans(85, 18, 27, 346), + Trans(85, 19, 27, 346), + Trans(85, 20, 27, 346), + Trans(85, 21, 27, 346), + Trans(85, 22, 27, 346), + Trans(85, 23, 27, 346), + Trans(85, 24, 27, 346), + Trans(85, 25, 27, 346), + Trans(85, 26, 27, 346), + Trans(85, 29, 27, 346), + Trans(85, 30, 27, 346), + Trans(85, 31, 27, 346), + Trans(85, 34, 27, 346), + Trans(85, 39, 27, 346), + Trans(85, 40, 27, 346), + Trans(85, 41, 27, 346), + Trans(85, 43, 27, 346), + Trans(85, 47, 27, 346), + Trans(85, 51, 27, 346), + Trans(85, 102, 27, 346), + Trans(86, 5, 27, 346), + Trans(86, 16, 27, 346), + Trans(86, 17, 27, 346), + Trans(86, 18, 27, 346), + Trans(86, 19, 27, 346), + Trans(86, 20, 27, 346), + Trans(86, 21, 27, 346), + Trans(86, 22, 27, 346), + Trans(86, 23, 27, 346), + Trans(86, 24, 27, 346), + Trans(86, 25, 27, 346), + Trans(86, 26, 27, 346), + Trans(86, 28, 27, 346), + Trans(86, 29, 27, 346), + Trans(86, 30, 27, 346), + Trans(86, 31, 27, 346), + Trans(86, 34, 27, 346), + Trans(86, 39, 27, 346), + Trans(86, 40, 27, 346), + Trans(86, 41, 27, 346), + Trans(86, 43, 27, 346), + Trans(86, 47, 27, 346), + Trans(86, 51, 27, 346), + Trans(86, 102, 27, 346), + Trans(87, 5, 27, 346), + Trans(87, 16, 27, 346), + Trans(87, 17, 27, 346), + Trans(87, 18, 27, 346), + Trans(87, 19, 27, 346), + Trans(87, 20, 27, 346), + Trans(87, 21, 27, 346), + Trans(87, 22, 27, 346), + Trans(87, 23, 27, 346), + Trans(87, 24, 27, 346), + Trans(87, 25, 27, 346), + Trans(87, 26, 27, 346), + Trans(87, 31, 27, 346), + Trans(87, 43, 27, 346), + Trans(87, 45, 27, 346), + Trans(87, 46, 27, 346), + Trans(87, 47, 27, 346), + Trans(87, 51, 27, 346), + Trans(88, 5, 27, 346), + Trans(88, 16, 27, 346), + Trans(88, 17, 27, 346), + Trans(88, 18, 27, 346), + Trans(88, 19, 27, 346), + Trans(88, 20, 27, 346), + Trans(88, 21, 27, 346), + Trans(88, 22, 27, 346), + Trans(88, 23, 27, 346), + Trans(88, 24, 27, 346), + Trans(88, 25, 27, 346), + Trans(88, 26, 27, 346), + Trans(88, 29, 27, 346), + Trans(88, 31, 27, 346), + Trans(88, 34, 27, 346), + Trans(88, 40, 27, 346), + Trans(88, 41, 27, 346), + Trans(88, 43, 27, 346), + Trans(88, 45, 27, 346), + Trans(88, 46, 27, 346), + Trans(88, 47, 27, 346), + Trans(88, 51, 27, 346), + Trans(89, 5, 27, 346), + Trans(89, 16, 27, 346), + Trans(89, 17, 27, 346), + Trans(89, 18, 27, 346), + Trans(89, 19, 27, 346), + Trans(89, 20, 27, 346), + Trans(89, 21, 27, 346), + Trans(89, 22, 27, 346), + Trans(89, 23, 27, 346), + Trans(89, 24, 27, 346), + Trans(89, 25, 27, 346), + Trans(89, 26, 27, 346), + Trans(89, 28, 27, 346), + Trans(89, 29, 27, 346), + Trans(89, 31, 27, 346), + Trans(89, 34, 27, 346), + Trans(89, 40, 27, 346), + Trans(89, 41, 27, 346), + Trans(89, 43, 27, 346), + Trans(89, 45, 27, 346), + Trans(89, 46, 27, 346), + Trans(89, 47, 27, 346), + Trans(89, 51, 27, 346), + Trans(90, 5, 27, 346), + Trans(90, 16, 27, 346), + Trans(90, 17, 27, 346), + Trans(90, 18, 27, 346), + Trans(90, 19, 27, 346), + Trans(90, 20, 27, 346), + Trans(90, 21, 27, 346), + Trans(90, 22, 27, 346), + Trans(90, 23, 27, 346), + Trans(90, 24, 27, 346), + Trans(90, 25, 27, 346), + Trans(90, 26, 27, 346), + Trans(90, 31, 27, 346), + Trans(90, 42, 27, 346), + Trans(90, 47, 27, 346), + Trans(90, 51, 27, 346), + Trans(91, 5, 27, 346), + Trans(91, 16, 27, 346), + Trans(91, 17, 27, 346), + Trans(91, 18, 27, 346), + Trans(91, 19, 27, 346), + Trans(91, 20, 27, 346), + Trans(91, 21, 27, 346), + Trans(91, 22, 27, 346), + Trans(91, 23, 27, 346), + Trans(91, 24, 27, 346), + Trans(91, 25, 27, 346), + Trans(91, 26, 27, 346), + Trans(91, 29, 27, 346), + Trans(91, 31, 27, 346), + Trans(91, 34, 27, 346), + Trans(91, 40, 27, 346), + Trans(91, 41, 27, 346), + Trans(91, 42, 27, 346), + Trans(91, 47, 27, 346), + Trans(91, 51, 27, 346), + Trans(92, 5, 27, 346), + Trans(92, 16, 27, 346), + Trans(92, 17, 27, 346), + Trans(92, 18, 27, 346), + Trans(92, 19, 27, 346), + Trans(92, 20, 27, 346), + Trans(92, 21, 27, 346), + Trans(92, 22, 27, 346), + Trans(92, 23, 27, 346), + Trans(92, 24, 27, 346), + Trans(92, 25, 27, 346), + Trans(92, 26, 27, 346), + Trans(92, 28, 27, 346), + Trans(92, 29, 27, 346), + Trans(92, 31, 27, 346), + Trans(92, 34, 27, 346), + Trans(92, 40, 27, 346), + Trans(92, 41, 27, 346), + Trans(92, 42, 27, 346), + Trans(92, 47, 27, 346), + Trans(92, 51, 27, 346), + Trans(93, 6, 27, 346), + Trans(93, 7, 27, 346), + Trans(93, 8, 27, 346), + Trans(93, 9, 27, 346), + Trans(93, 10, 27, 346), + Trans(93, 11, 27, 346), + Trans(93, 18, 27, 346), + Trans(93, 24, 27, 346), + Trans(93, 25, 27, 346), + Trans(93, 26, 27, 346), + Trans(93, 27, 27, 346), + Trans(93, 30, 27, 346), + Trans(93, 36, 27, 346), + Trans(93, 38, 27, 346), + Trans(93, 39, 27, 346), + Trans(93, 41, 27, 346), + Trans(93, 43, 27, 346), + Trans(93, 48, 27, 346), + Trans(93, 49, 27, 346), + Trans(93, 50, 27, 346), + Trans(93, 53, 27, 346), + Trans(93, 57, 27, 346), + Trans(93, 60, 27, 346), + Trans(93, 64, 27, 346), + Trans(93, 65, 27, 346), + Trans(93, 66, 27, 346), + Trans(93, 69, 27, 346), + Trans(93, 70, 27, 346), + Trans(93, 71, 27, 346), + Trans(93, 73, 27, 346), + Trans(93, 76, 27, 346), + Trans(93, 77, 27, 346), + Trans(93, 80, 27, 346), + Trans(93, 81, 27, 346), + Trans(93, 83, 27, 346), + Trans(93, 84, 27, 346), + Trans(93, 86, 27, 346), + Trans(93, 88, 27, 346), + Trans(93, 99, 27, 346), + Trans(93, 100, 27, 346), + Trans(93, 104, 27, 346), + Trans(93, 106, 27, 346), + Trans(93, 109, 27, 346), + Trans(93, 110, 27, 346), + Trans(93, 111, 27, 346), + Trans(93, 112, 27, 346), + Trans(94, 5, 27, 346), + Trans(94, 16, 27, 346), + Trans(94, 17, 27, 346), + Trans(94, 18, 27, 346), + Trans(94, 19, 27, 346), + Trans(94, 20, 27, 346), + Trans(94, 21, 27, 346), + Trans(94, 22, 27, 346), + Trans(94, 23, 27, 346), + Trans(94, 24, 27, 346), + Trans(94, 25, 27, 346), + Trans(94, 26, 27, 346), + Trans(94, 30, 27, 346), + Trans(94, 31, 27, 346), + Trans(94, 32, 27, 346), + Trans(94, 33, 27, 346), + Trans(94, 43, 27, 346), + Trans(94, 47, 27, 346), + Trans(94, 51, 27, 346), + Trans(95, 5, 27, 346), + Trans(95, 6, 27, 346), + Trans(95, 7, 27, 346), + Trans(95, 8, 27, 346), + Trans(95, 9, 27, 346), + Trans(95, 10, 27, 346), + Trans(95, 11, 27, 346), + Trans(95, 18, 27, 346), + Trans(95, 24, 27, 346), + Trans(95, 25, 27, 346), + Trans(95, 26, 27, 346), + Trans(95, 27, 27, 346), + Trans(95, 30, 27, 346), + Trans(95, 36, 27, 346), + Trans(95, 38, 27, 346), + Trans(95, 39, 27, 346), + Trans(95, 41, 27, 346), + Trans(95, 43, 27, 346), + Trans(95, 48, 27, 346), + Trans(95, 49, 27, 346), + Trans(95, 50, 27, 346), + Trans(95, 53, 27, 346), + Trans(95, 60, 27, 346), + Trans(95, 64, 27, 346), + Trans(95, 65, 27, 346), + Trans(95, 66, 27, 346), + Trans(95, 70, 27, 346), + Trans(95, 71, 27, 346), + Trans(95, 73, 27, 346), + Trans(95, 76, 27, 346), + Trans(95, 77, 27, 346), + Trans(95, 80, 27, 346), + Trans(95, 81, 27, 346), + Trans(95, 83, 27, 346), + Trans(95, 84, 27, 346), + Trans(95, 86, 27, 346), + Trans(95, 88, 27, 346), + Trans(95, 104, 27, 346), + Trans(95, 106, 27, 346), + Trans(95, 109, 27, 346), + Trans(95, 110, 27, 346), + Trans(95, 111, 27, 346), + Trans(95, 112, 27, 346), + Trans(96, 5, 27, 346), + Trans(96, 6, 27, 346), + Trans(96, 7, 27, 346), + Trans(96, 8, 27, 346), + Trans(96, 9, 27, 346), + Trans(96, 10, 27, 346), + Trans(96, 11, 27, 346), + Trans(96, 18, 27, 346), + Trans(96, 24, 27, 346), + Trans(96, 25, 27, 346), + Trans(96, 26, 27, 346), + Trans(96, 27, 27, 346), + Trans(96, 30, 27, 346), + Trans(96, 36, 27, 346), + Trans(96, 38, 27, 346), + Trans(96, 39, 27, 346), + Trans(96, 41, 27, 346), + Trans(96, 43, 27, 346), + Trans(96, 48, 27, 346), + Trans(96, 49, 27, 346), + Trans(96, 50, 27, 346), + Trans(96, 53, 27, 346), + Trans(96, 57, 27, 346), + Trans(96, 58, 27, 346), + Trans(96, 60, 27, 346), + Trans(96, 61, 27, 346), + Trans(96, 64, 27, 346), + Trans(96, 65, 27, 346), + Trans(96, 66, 27, 346), + Trans(96, 69, 27, 346), + Trans(96, 70, 27, 346), + Trans(96, 71, 27, 346), + Trans(96, 73, 27, 346), + Trans(96, 76, 27, 346), + Trans(96, 77, 27, 346), + Trans(96, 80, 27, 346), + Trans(96, 81, 27, 346), + Trans(96, 83, 27, 346), + Trans(96, 84, 27, 346), + Trans(96, 86, 27, 346), + Trans(96, 88, 27, 346), + Trans(96, 99, 27, 346), + Trans(96, 100, 27, 346), + Trans(96, 104, 27, 346), + Trans(96, 106, 27, 346), + Trans(96, 109, 27, 346), + Trans(96, 110, 27, 346), + Trans(96, 111, 27, 346), + Trans(96, 112, 27, 346), + Trans(97, 5, 27, 346), + Trans(97, 15, 27, 346), + Trans(97, 16, 27, 346), + Trans(97, 17, 27, 346), + Trans(97, 18, 27, 346), + Trans(97, 19, 27, 346), + Trans(97, 20, 27, 346), + Trans(97, 21, 27, 346), + Trans(97, 22, 27, 346), + Trans(97, 23, 27, 346), + Trans(97, 24, 27, 346), + Trans(97, 25, 27, 346), + Trans(97, 26, 27, 346), + Trans(97, 29, 27, 346), + Trans(97, 30, 27, 346), + Trans(97, 31, 27, 346), + Trans(97, 32, 27, 346), + Trans(97, 33, 27, 346), + Trans(97, 34, 27, 346), + Trans(97, 35, 27, 346), + Trans(97, 40, 27, 346), + Trans(97, 41, 27, 346), + Trans(97, 43, 27, 346), + Trans(97, 47, 27, 346), + Trans(97, 51, 27, 346), + Trans(98, 5, 27, 346), + Trans(98, 15, 27, 346), + Trans(98, 16, 27, 346), + Trans(98, 17, 27, 346), + Trans(98, 18, 27, 346), + Trans(98, 19, 27, 346), + Trans(98, 20, 27, 346), + Trans(98, 21, 27, 346), + Trans(98, 22, 27, 346), + Trans(98, 23, 27, 346), + Trans(98, 24, 27, 346), + Trans(98, 25, 27, 346), + Trans(98, 26, 27, 346), + Trans(98, 28, 27, 346), + Trans(98, 29, 27, 346), + Trans(98, 30, 27, 346), + Trans(98, 31, 27, 346), + Trans(98, 32, 27, 346), + Trans(98, 33, 27, 346), + Trans(98, 34, 27, 346), + Trans(98, 35, 27, 346), + Trans(98, 40, 27, 346), + Trans(98, 41, 27, 346), + Trans(98, 43, 27, 346), + Trans(98, 47, 27, 346), + Trans(98, 51, 27, 346), + Trans(99, 5, 27, 346), + Trans(99, 12, 27, 346), + Trans(99, 14, 27, 346), + Trans(99, 16, 27, 346), + Trans(99, 17, 27, 346), + Trans(99, 18, 27, 346), + Trans(99, 19, 27, 346), + Trans(99, 20, 27, 346), + Trans(99, 21, 27, 346), + Trans(99, 22, 27, 346), + Trans(99, 23, 27, 346), + Trans(99, 24, 27, 346), + Trans(99, 25, 27, 346), + Trans(99, 26, 27, 346), + Trans(99, 30, 27, 346), + Trans(99, 31, 27, 346), + Trans(99, 44, 27, 346), + Trans(99, 47, 27, 346), + Trans(99, 51, 27, 346), + Trans(99, 102, 27, 346), + Trans(100, 5, 27, 346), + Trans(100, 12, 27, 346), + Trans(100, 14, 27, 346), + Trans(100, 16, 27, 346), + Trans(100, 17, 27, 346), + Trans(100, 18, 27, 346), + Trans(100, 19, 27, 346), + Trans(100, 20, 27, 346), + Trans(100, 21, 27, 346), + Trans(100, 22, 27, 346), + Trans(100, 23, 27, 346), + Trans(100, 24, 27, 346), + Trans(100, 25, 27, 346), + Trans(100, 26, 27, 346), + Trans(100, 29, 27, 346), + Trans(100, 30, 27, 346), + Trans(100, 31, 27, 346), + Trans(100, 34, 27, 346), + Trans(100, 40, 27, 346), + Trans(100, 41, 27, 346), + Trans(100, 44, 27, 346), + Trans(100, 47, 27, 346), + Trans(100, 51, 27, 346), + Trans(100, 102, 27, 346), + Trans(101, 5, 27, 346), + Trans(101, 12, 27, 346), + Trans(101, 14, 27, 346), + Trans(101, 16, 27, 346), + Trans(101, 17, 27, 346), + Trans(101, 18, 27, 346), + Trans(101, 19, 27, 346), + Trans(101, 20, 27, 346), + Trans(101, 21, 27, 346), + Trans(101, 22, 27, 346), + Trans(101, 23, 27, 346), + Trans(101, 24, 27, 346), + Trans(101, 25, 27, 346), + Trans(101, 26, 27, 346), + Trans(101, 28, 27, 346), + Trans(101, 29, 27, 346), + Trans(101, 30, 27, 346), + Trans(101, 31, 27, 346), + Trans(101, 34, 27, 346), + Trans(101, 40, 27, 346), + Trans(101, 41, 27, 346), + Trans(101, 44, 27, 346), + Trans(101, 47, 27, 346), + Trans(101, 51, 27, 346), + Trans(101, 102, 27, 346), + Trans(102, 6, 27, 346), + Trans(102, 7, 27, 346), + Trans(102, 8, 27, 346), + Trans(102, 9, 27, 346), + Trans(102, 10, 27, 346), + Trans(102, 11, 27, 346), + Trans(102, 18, 27, 346), + Trans(102, 24, 27, 346), + Trans(102, 25, 27, 346), + Trans(102, 26, 27, 346), + Trans(102, 27, 27, 346), + Trans(102, 36, 27, 346), + Trans(102, 38, 27, 346), + Trans(102, 39, 27, 346), + Trans(102, 41, 27, 346), + Trans(102, 45, 27, 346), + Trans(102, 53, 27, 346), + Trans(102, 70, 27, 346), + Trans(102, 76, 27, 346), + Trans(102, 83, 27, 346), + Trans(102, 86, 27, 346), + Trans(102, 88, 27, 346), + Trans(102, 111, 27, 346), + Trans(102, 112, 27, 346), + Trans(103, 5, 27, 346), + Trans(103, 16, 27, 346), + Trans(103, 17, 27, 346), + Trans(103, 18, 27, 346), + Trans(103, 19, 27, 346), + Trans(103, 20, 27, 346), + Trans(103, 21, 27, 346), + Trans(103, 22, 27, 346), + Trans(103, 23, 27, 346), + Trans(103, 24, 27, 346), + Trans(103, 25, 27, 346), + Trans(103, 26, 27, 346), + Trans(103, 31, 27, 346), + Trans(103, 45, 27, 346), + Trans(103, 47, 27, 346), + Trans(103, 51, 27, 346), + Trans(104, 5, 27, 346), + Trans(104, 6, 27, 346), + Trans(104, 7, 27, 346), + Trans(104, 8, 27, 346), + Trans(104, 9, 27, 346), + Trans(104, 10, 27, 346), + Trans(104, 11, 27, 346), + Trans(104, 18, 27, 346), + Trans(104, 24, 27, 346), + Trans(104, 25, 27, 346), + Trans(104, 26, 27, 346), + Trans(104, 27, 27, 346), + Trans(104, 36, 27, 346), + Trans(104, 38, 27, 346), + Trans(104, 39, 27, 346), + Trans(104, 41, 27, 346), + Trans(104, 53, 27, 346), + Trans(104, 70, 27, 346), + Trans(104, 76, 27, 346), + Trans(104, 83, 27, 346), + Trans(104, 86, 27, 346), + Trans(104, 88, 27, 346), + Trans(104, 111, 27, 346), + Trans(104, 112, 27, 346), + Trans(105, 5, 27, 346), + Trans(105, 16, 27, 346), + Trans(105, 17, 27, 346), + Trans(105, 18, 27, 346), + Trans(105, 19, 27, 346), + Trans(105, 20, 27, 346), + Trans(105, 21, 27, 346), + Trans(105, 22, 27, 346), + Trans(105, 23, 27, 346), + Trans(105, 24, 27, 346), + Trans(105, 25, 27, 346), + Trans(105, 26, 27, 346), + Trans(105, 29, 27, 346), + Trans(105, 31, 27, 346), + Trans(105, 34, 27, 346), + Trans(105, 40, 27, 346), + Trans(105, 41, 27, 346), + Trans(105, 45, 27, 346), + Trans(105, 47, 27, 346), + Trans(105, 51, 27, 346), + Trans(106, 5, 27, 346), + Trans(106, 16, 27, 346), + Trans(106, 17, 27, 346), + Trans(106, 18, 27, 346), + Trans(106, 19, 27, 346), + Trans(106, 20, 27, 346), + Trans(106, 21, 27, 346), + Trans(106, 22, 27, 346), + Trans(106, 23, 27, 346), + Trans(106, 24, 27, 346), + Trans(106, 25, 27, 346), + Trans(106, 26, 27, 346), + Trans(106, 28, 27, 346), + Trans(106, 29, 27, 346), + Trans(106, 30, 27, 346), + Trans(106, 31, 27, 346), + Trans(106, 34, 27, 346), + Trans(106, 40, 27, 346), + Trans(106, 41, 27, 346), + Trans(106, 45, 27, 346), + Trans(106, 47, 27, 346), + Trans(106, 51, 27, 346), + Trans(107, 5, 27, 346), + Trans(107, 16, 27, 346), + Trans(107, 17, 27, 346), + Trans(107, 18, 27, 346), + Trans(107, 19, 27, 346), + Trans(107, 20, 27, 346), + Trans(107, 21, 27, 346), + Trans(107, 22, 27, 346), + Trans(107, 23, 27, 346), + Trans(107, 24, 27, 346), + Trans(107, 25, 27, 346), + Trans(107, 26, 27, 346), + Trans(107, 32, 27, 346), + Trans(107, 33, 27, 346), + Trans(107, 39, 27, 346), + Trans(107, 47, 27, 346), + Trans(107, 51, 27, 346), + Trans(107, 102, 27, 346), + Trans(108, 5, 27, 346), + Trans(108, 16, 27, 346), + Trans(108, 17, 27, 346), + Trans(108, 18, 27, 346), + Trans(108, 19, 27, 346), + Trans(108, 20, 27, 346), + Trans(108, 21, 27, 346), + Trans(108, 22, 27, 346), + Trans(108, 23, 27, 346), + Trans(108, 24, 27, 346), + Trans(108, 25, 27, 346), + Trans(108, 26, 27, 346), + Trans(108, 29, 27, 346), + Trans(108, 32, 27, 346), + Trans(108, 33, 27, 346), + Trans(108, 34, 27, 346), + Trans(108, 39, 27, 346), + Trans(108, 40, 27, 346), + Trans(108, 41, 27, 346), + Trans(108, 47, 27, 346), + Trans(108, 51, 27, 346), + Trans(108, 102, 27, 346), + Trans(109, 5, 27, 346), + Trans(109, 16, 27, 346), + Trans(109, 17, 27, 346), + Trans(109, 18, 27, 346), + Trans(109, 19, 27, 346), + Trans(109, 20, 27, 346), + Trans(109, 21, 27, 346), + Trans(109, 22, 27, 346), + Trans(109, 23, 27, 346), + Trans(109, 24, 27, 346), + Trans(109, 25, 27, 346), + Trans(109, 26, 27, 346), + Trans(109, 28, 27, 346), + Trans(109, 29, 27, 346), + Trans(109, 32, 27, 346), + Trans(109, 33, 27, 346), + Trans(109, 34, 27, 346), + Trans(109, 39, 27, 346), + Trans(109, 40, 27, 346), + Trans(109, 41, 27, 346), + Trans(109, 47, 27, 346), + Trans(109, 51, 27, 346), + Trans(109, 102, 27, 346), + Trans(110, 5, 27, 346), + Trans(110, 16, 27, 346), + Trans(110, 17, 27, 346), + Trans(110, 18, 27, 346), + Trans(110, 19, 27, 346), + Trans(110, 20, 27, 346), + Trans(110, 21, 27, 346), + Trans(110, 22, 27, 346), + Trans(110, 23, 27, 346), + Trans(110, 24, 27, 346), + Trans(110, 25, 27, 346), + Trans(110, 26, 27, 346), + Trans(110, 31, 27, 346), + Trans(110, 43, 27, 346), + Trans(110, 47, 27, 346), + Trans(110, 51, 27, 346), + Trans(111, 5, 27, 346), + Trans(111, 16, 27, 346), + Trans(111, 17, 27, 346), + Trans(111, 18, 27, 346), + Trans(111, 19, 27, 346), + Trans(111, 20, 27, 346), + Trans(111, 21, 27, 346), + Trans(111, 22, 27, 346), + Trans(111, 23, 27, 346), + Trans(111, 24, 27, 346), + Trans(111, 25, 27, 346), + Trans(111, 26, 27, 346), + Trans(111, 29, 27, 346), + Trans(111, 31, 27, 346), + Trans(111, 34, 27, 346), + Trans(111, 40, 27, 346), + Trans(111, 41, 27, 346), + Trans(111, 43, 27, 346), + Trans(111, 47, 27, 346), + Trans(111, 51, 27, 346), + Trans(112, 5, 27, 346), + Trans(112, 16, 27, 346), + Trans(112, 17, 27, 346), + Trans(112, 18, 27, 346), + Trans(112, 19, 27, 346), + Trans(112, 20, 27, 346), + Trans(112, 21, 27, 346), + Trans(112, 22, 27, 346), + Trans(112, 23, 27, 346), + Trans(112, 24, 27, 346), + Trans(112, 25, 27, 346), + Trans(112, 26, 27, 346), + Trans(112, 28, 27, 346), + Trans(112, 29, 27, 346), + Trans(112, 31, 27, 346), + Trans(112, 34, 27, 346), + Trans(112, 40, 27, 346), + Trans(112, 41, 27, 346), + Trans(112, 43, 27, 346), + Trans(112, 47, 27, 346), + Trans(112, 51, 27, 346), + Trans(113, 6, 27, 346), + Trans(113, 7, 27, 346), + Trans(113, 8, 27, 346), + Trans(113, 9, 27, 346), + Trans(113, 10, 27, 346), + Trans(113, 11, 27, 346), + Trans(113, 15, 27, 346), + Trans(113, 18, 27, 346), + Trans(113, 24, 27, 346), + Trans(113, 25, 27, 346), + Trans(113, 26, 27, 346), + Trans(113, 27, 27, 346), + Trans(113, 38, 27, 346), + Trans(113, 39, 27, 346), + Trans(113, 41, 27, 346), + Trans(113, 53, 27, 346), + Trans(113, 70, 27, 346), + Trans(113, 76, 27, 346), + Trans(113, 83, 27, 346), + Trans(113, 86, 27, 346), + Trans(113, 88, 27, 346), + Trans(113, 111, 27, 346), + Trans(113, 112, 27, 346), + Trans(114, 12, 27, 346), + Trans(114, 14, 27, 346), + Trans(114, 15, 27, 346), + Trans(114, 16, 27, 346), + Trans(114, 17, 27, 346), + Trans(114, 18, 27, 346), + Trans(114, 19, 27, 346), + Trans(114, 20, 27, 346), + Trans(114, 21, 27, 346), + Trans(114, 22, 27, 346), + Trans(114, 23, 27, 346), + Trans(114, 24, 27, 346), + Trans(114, 25, 27, 346), + Trans(114, 26, 27, 346), + Trans(114, 30, 27, 346), + Trans(114, 31, 27, 346), + Trans(114, 32, 27, 346), + Trans(114, 33, 27, 346), + Trans(114, 34, 27, 346), + Trans(114, 35, 27, 346), + Trans(114, 36, 27, 346), + Trans(114, 39, 27, 346), + Trans(114, 40, 27, 346), + Trans(114, 41, 27, 346), + Trans(114, 42, 27, 346), + Trans(114, 43, 27, 346), + Trans(114, 44, 27, 346), + Trans(114, 45, 27, 346), + Trans(114, 46, 27, 346), + Trans(114, 47, 27, 346), + Trans(114, 51, 27, 346), + Trans(114, 93, 27, 346), + Trans(114, 102, 27, 346), + Trans(115, 12, 27, 346), + Trans(115, 13, 27, 346), + Trans(115, 14, 27, 346), + Trans(115, 16, 27, 346), + Trans(115, 17, 27, 346), + Trans(115, 18, 27, 346), + Trans(115, 19, 27, 346), + Trans(115, 20, 27, 346), + Trans(115, 21, 27, 346), + Trans(115, 22, 27, 346), + Trans(115, 23, 27, 346), + Trans(115, 24, 27, 346), + Trans(115, 25, 27, 346), + Trans(115, 26, 27, 346), + Trans(115, 30, 27, 346), + Trans(115, 31, 27, 346), + Trans(115, 32, 27, 346), + Trans(115, 33, 27, 346), + Trans(115, 39, 27, 346), + Trans(115, 41, 27, 346), + Trans(115, 42, 27, 346), + Trans(115, 43, 27, 346), + Trans(115, 44, 27, 346), + Trans(115, 45, 27, 346), + Trans(115, 46, 27, 346), + Trans(115, 47, 27, 346), + Trans(115, 51, 27, 346), + Trans(115, 93, 27, 346), + Trans(115, 102, 27, 346), + Trans(116, 5, 27, 346), + Trans(116, 52, 27, 346), + Trans(116, 54, 27, 346), + Trans(116, 55, 27, 346), + Trans(116, 56, 27, 346), + Trans(116, 62, 27, 346), + Trans(116, 63, 27, 346), + Trans(116, 67, 27, 346), + Trans(116, 68, 27, 346), + Trans(116, 82, 27, 346), + Trans(116, 94, 27, 346), + Trans(116, 95, 27, 346), + Trans(116, 96, 27, 346), + Trans(116, 97, 27, 346), + Trans(116, 98, 27, 346), + Trans(116, 101, 27, 346), + Trans(116, 103, 27, 346), + Trans(116, 105, 27, 346), + Trans(116, 107, 27, 346), + Trans(116, 108, 27, 346), + Trans(116, 111, 27, 346), + Trans(116, 112, 27, 346), + Trans(117, 5, 27, 346), + Trans(117, 36, 27, 346), + Trans(117, 39, 27, 346), + Trans(117, 45, 27, 346), + Trans(117, 112, 27, 346), + Trans(118, 5, 27, 346), + Trans(118, 12, 27, 346), + Trans(118, 14, 27, 346), + Trans(118, 16, 27, 346), + Trans(118, 17, 27, 346), + Trans(118, 18, 27, 346), + Trans(118, 19, 27, 346), + Trans(118, 20, 27, 346), + Trans(118, 21, 27, 346), + Trans(118, 22, 27, 346), + Trans(118, 23, 27, 346), + Trans(118, 24, 27, 346), + Trans(118, 25, 27, 346), + Trans(118, 26, 27, 346), + Trans(118, 30, 27, 346), + Trans(118, 31, 27, 346), + Trans(118, 32, 27, 346), + Trans(118, 33, 27, 346), + Trans(118, 39, 27, 346), + Trans(118, 41, 27, 346), + Trans(118, 42, 27, 346), + Trans(118, 43, 27, 346), + Trans(118, 44, 27, 346), + Trans(118, 45, 27, 346), + Trans(118, 46, 27, 346), + Trans(118, 47, 27, 346), + Trans(118, 51, 27, 346), + Trans(118, 93, 27, 346), + Trans(118, 102, 27, 346), + Trans(119, 41, 27, 346), + Trans(120, 111, 27, 346), + Trans(120, 112, 27, 346), + Trans(121, 5, 27, 346), + Trans(121, 12, 27, 346), + Trans(121, 14, 27, 346), + Trans(121, 16, 27, 346), + Trans(121, 17, 27, 346), + Trans(121, 18, 27, 346), + Trans(121, 19, 27, 346), + Trans(121, 20, 27, 346), + Trans(121, 21, 27, 346), + Trans(121, 22, 27, 346), + Trans(121, 23, 27, 346), + Trans(121, 24, 27, 346), + Trans(121, 25, 27, 346), + Trans(121, 26, 27, 346), + Trans(121, 29, 27, 346), + Trans(121, 30, 27, 346), + Trans(121, 31, 27, 346), + Trans(121, 32, 27, 346), + Trans(121, 33, 27, 346), + Trans(121, 39, 27, 346), + Trans(121, 42, 27, 346), + Trans(121, 43, 27, 346), + Trans(121, 44, 27, 346), + Trans(121, 45, 27, 346), + Trans(121, 46, 27, 346), + Trans(121, 47, 27, 346), + Trans(121, 51, 27, 346), + Trans(121, 93, 27, 346), + Trans(121, 102, 27, 346), + Trans(122, 5, 27, 346), + Trans(122, 12, 27, 346), + Trans(122, 14, 27, 346), + Trans(122, 16, 27, 346), + Trans(122, 17, 27, 346), + Trans(122, 18, 27, 346), + Trans(122, 19, 27, 346), + Trans(122, 20, 27, 346), + Trans(122, 21, 27, 346), + Trans(122, 22, 27, 346), + Trans(122, 23, 27, 346), + Trans(122, 24, 27, 346), + Trans(122, 25, 27, 346), + Trans(122, 26, 27, 346), + Trans(122, 28, 27, 346), + Trans(122, 29, 27, 346), + Trans(122, 30, 27, 346), + Trans(122, 31, 27, 346), + Trans(122, 32, 27, 346), + Trans(122, 33, 27, 346), + Trans(122, 39, 27, 346), + Trans(122, 42, 27, 346), + Trans(122, 43, 27, 346), + Trans(122, 44, 27, 346), + Trans(122, 45, 27, 346), + Trans(122, 46, 27, 346), + Trans(122, 47, 27, 346), + Trans(122, 51, 27, 346), + Trans(122, 93, 27, 346), + Trans(122, 102, 27, 346), + Trans(123, 112, 27, 346), + Trans(124, 5, 27, 346), + Trans(124, 12, 27, 346), + Trans(124, 14, 27, 346), + Trans(124, 15, 27, 346), + Trans(124, 16, 27, 346), + Trans(124, 17, 27, 346), + Trans(124, 18, 27, 346), + Trans(124, 19, 27, 346), + Trans(124, 20, 27, 346), + Trans(124, 21, 27, 346), + Trans(124, 22, 27, 346), + Trans(124, 23, 27, 346), + Trans(124, 24, 27, 346), + Trans(124, 25, 27, 346), + Trans(124, 26, 27, 346), + Trans(124, 30, 27, 346), + Trans(124, 31, 27, 346), + Trans(124, 32, 27, 346), + Trans(124, 33, 27, 346), + Trans(124, 34, 27, 346), + Trans(124, 35, 27, 346), + Trans(124, 39, 27, 346), + Trans(124, 40, 27, 346), + Trans(124, 41, 27, 346), + Trans(124, 42, 27, 346), + Trans(124, 43, 27, 346), + Trans(124, 44, 27, 346), + Trans(124, 45, 27, 346), + Trans(124, 46, 27, 346), + Trans(124, 47, 27, 346), + Trans(124, 51, 27, 346), + Trans(124, 93, 27, 346), + Trans(124, 102, 27, 346), ], k: 3, }, - /* 537 - "Select" */ + /* 544 - "ScopedIdentifierOpt" */ LookaheadDFA { - prod0: 461, + prod0: -1, + transitions: &[ + Trans(0, 12, 2, 350), + Trans(0, 14, 2, 350), + Trans(0, 15, 2, 350), + Trans(0, 16, 2, 350), + Trans(0, 17, 2, 350), + Trans(0, 18, 2, 350), + Trans(0, 19, 2, 350), + Trans(0, 20, 2, 350), + Trans(0, 21, 2, 350), + Trans(0, 22, 2, 350), + Trans(0, 23, 2, 350), + Trans(0, 24, 2, 350), + Trans(0, 25, 2, 350), + Trans(0, 26, 2, 350), + Trans(0, 28, 1, 349), + Trans(0, 29, 2, 350), + Trans(0, 30, 2, 350), + Trans(0, 31, 2, 350), + Trans(0, 32, 2, 350), + Trans(0, 33, 2, 350), + Trans(0, 34, 2, 350), + Trans(0, 35, 2, 350), + Trans(0, 36, 2, 350), + Trans(0, 37, 2, 350), + Trans(0, 39, 2, 350), + Trans(0, 40, 2, 350), + Trans(0, 41, 2, 350), + Trans(0, 42, 2, 350), + Trans(0, 43, 2, 350), + Trans(0, 44, 2, 350), + Trans(0, 45, 2, 350), + Trans(0, 46, 2, 350), + Trans(0, 47, 2, 350), + Trans(0, 51, 2, 350), + Trans(0, 79, 2, 350), + Trans(0, 93, 2, 350), + Trans(0, 102, 2, 350), + ], + k: 1, + }, + /* 545 - "ScopedIdentifierOpt0" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 12, 2, 348), + Trans(0, 14, 2, 348), + Trans(0, 15, 2, 348), + Trans(0, 16, 2, 348), + Trans(0, 17, 2, 348), + Trans(0, 18, 2, 348), + Trans(0, 19, 2, 348), + Trans(0, 20, 2, 348), + Trans(0, 21, 2, 348), + Trans(0, 22, 2, 348), + Trans(0, 23, 2, 348), + Trans(0, 24, 2, 348), + Trans(0, 25, 2, 348), + Trans(0, 26, 2, 348), + Trans(0, 28, 1, 347), + Trans(0, 29, 2, 348), + Trans(0, 30, 2, 348), + Trans(0, 31, 2, 348), + Trans(0, 32, 2, 348), + Trans(0, 33, 2, 348), + Trans(0, 34, 2, 348), + Trans(0, 35, 2, 348), + Trans(0, 36, 2, 348), + Trans(0, 37, 2, 348), + Trans(0, 39, 2, 348), + Trans(0, 40, 2, 348), + Trans(0, 41, 2, 348), + Trans(0, 42, 2, 348), + Trans(0, 43, 2, 348), + Trans(0, 44, 2, 348), + Trans(0, 45, 2, 348), + Trans(0, 46, 2, 348), + Trans(0, 47, 2, 348), + Trans(0, 51, 2, 348), + Trans(0, 79, 2, 348), + Trans(0, 93, 2, 348), + Trans(0, 102, 2, 348), + ], + k: 1, + }, + /* 546 - "Select" */ + LookaheadDFA { + prod0: 468, transitions: &[], k: 0, }, - /* 538 - "SelectOperator" */ + /* 547 - "SelectOperator" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 3, 466), - Trans(0, 14, 2, 465), - Trans(0, 29, 1, 464), - Trans(0, 101, 4, 467), + Trans(0, 12, 3, 473), + Trans(0, 14, 2, 472), + Trans(0, 30, 1, 471), + Trans(0, 102, 4, 474), ], k: 1, }, - /* 539 - "SelectOpt" */ + /* 548 - "SelectOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 12, 1, 462), - Trans(0, 14, 1, 462), - Trans(0, 29, 1, 462), - Trans(0, 43, 2, 463), - Trans(0, 101, 1, 462), + Trans(0, 12, 1, 469), + Trans(0, 14, 1, 469), + Trans(0, 30, 1, 469), + Trans(0, 44, 2, 470), + Trans(0, 102, 1, 469), ], k: 1, }, - /* 540 - "Semicolon" */ + /* 549 - "Semicolon" */ LookaheadDFA { - prod0: 258, + prod0: 261, transitions: &[], k: 0, }, - /* 541 - "SemicolonTerm" */ + /* 550 - "SemicolonTerm" */ LookaheadDFA { - prod0: 40, + prod0: 41, transitions: &[], k: 0, }, - /* 542 - "SemicolonToken" */ + /* 551 - "SemicolonToken" */ LookaheadDFA { - prod0: 151, + prod0: 153, transitions: &[], k: 0, }, - /* 543 - "Signed" */ + /* 552 - "Signed" */ LookaheadDFA { - prod0: 313, + prod0: 316, transitions: &[], k: 0, }, - /* 544 - "SignedTerm" */ + /* 553 - "SignedTerm" */ LookaheadDFA { - prod0: 95, + prod0: 96, transitions: &[], k: 0, }, - /* 545 - "SignedToken" */ + /* 554 - "SignedToken" */ LookaheadDFA { - prod0: 206, + prod0: 208, transitions: &[], k: 0, }, - /* 546 - "Star" */ + /* 555 - "Star" */ LookaheadDFA { - prod0: 259, + prod0: 262, transitions: &[], k: 0, }, - /* 547 - "StarTerm" */ + /* 556 - "StarTerm" */ LookaheadDFA { - prod0: 41, + prod0: 42, transitions: &[], k: 0, }, - /* 548 - "StarToken" */ + /* 557 - "StarToken" */ LookaheadDFA { - prod0: 152, + prod0: 154, transitions: &[], k: 0, }, - /* 549 - "Start" */ + /* 558 - "Start" */ LookaheadDFA { - prod0: 218, + prod0: 220, transitions: &[], k: 0, }, - /* 550 - "StartToken" */ + /* 559 - "StartToken" */ LookaheadDFA { - prod0: 111, + prod0: 112, transitions: &[], k: 0, }, - /* 551 - "Statement" */ + /* 560 - "Statement" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 52, 8, 517), - Trans(0, 64, 7, 516), - Trans(0, 68, 4, 513), - Trans(0, 69, 3, 512), - Trans(0, 79, 1, 510), - Trans(0, 98, 5, 514), - Trans(0, 99, 6, 515), - Trans(0, 110, 2, 511), - Trans(0, 111, 2, 511), + Trans(0, 53, 8, 524), + Trans(0, 65, 7, 523), + Trans(0, 69, 4, 520), + Trans(0, 70, 3, 519), + Trans(0, 80, 1, 517), + Trans(0, 99, 5, 521), + Trans(0, 100, 6, 522), + Trans(0, 111, 2, 518), + Trans(0, 112, 2, 518), ], k: 1, }, - /* 552 - "Step" */ + /* 561 - "Step" */ LookaheadDFA { - prod0: 314, + prod0: 317, transitions: &[], k: 0, }, - /* 553 - "StepTerm" */ + /* 562 - "StepTerm" */ LookaheadDFA { - prod0: 96, + prod0: 97, transitions: &[], k: 0, }, - /* 554 - "StepToken" */ + /* 563 - "StepToken" */ LookaheadDFA { - prod0: 207, + prod0: 209, transitions: &[], k: 0, }, - /* 555 - "Strin" */ + /* 564 - "Strin" */ LookaheadDFA { - prod0: 315, + prod0: 318, transitions: &[], k: 0, }, - /* 556 - "StringLiteral" */ + /* 565 - "StringLiteral" */ LookaheadDFA { - prod0: 219, + prod0: 221, transitions: &[], k: 0, }, - /* 557 - "StringLiteralTerm" */ + /* 566 - "StringLiteralTerm" */ LookaheadDFA { prod0: 1, transitions: &[], k: 0, }, - /* 558 - "StringLiteralToken" */ + /* 567 - "StringLiteralToken" */ LookaheadDFA { - prod0: 112, + prod0: 113, transitions: &[], k: 0, }, - /* 559 - "StringTerm" */ + /* 568 - "StringTerm" */ LookaheadDFA { - prod0: 97, + prod0: 98, transitions: &[], k: 0, }, - /* 560 - "StringToken" */ + /* 569 - "StringToken" */ LookaheadDFA { - prod0: 208, + prod0: 210, transitions: &[], k: 0, }, - /* 561 - "Struct" */ + /* 570 - "Struct" */ LookaheadDFA { - prod0: 316, + prod0: 319, transitions: &[], k: 0, }, - /* 562 - "StructTerm" */ + /* 571 - "StructTerm" */ LookaheadDFA { - prod0: 98, + prod0: 99, transitions: &[], k: 0, }, - /* 563 - "StructToken" */ + /* 572 - "StructToken" */ LookaheadDFA { - prod0: 209, + prod0: 211, transitions: &[], k: 0, }, - /* 564 - "StructUnion" */ + /* 573 - "StructUnion" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 103, 1, 619), Trans(0, 108, 2, 620)], + transitions: &[Trans(0, 104, 1, 626), Trans(0, 109, 2, 627)], k: 1, }, - /* 565 - "StructUnionDeclaration" */ + /* 574 - "StructUnionDeclaration" */ LookaheadDFA { - prod0: 621, + prod0: 628, transitions: &[], k: 0, }, - /* 566 - "StructUnionGroup" */ + /* 575 - "StructUnionDeclarationOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 28, 1, 629), Trans(0, 39, 2, 630)], + k: 1, + }, + /* 576 - "StructUnionGroup" */ LookaheadDFA { - prod0: 627, + prod0: 636, transitions: &[], k: 0, }, - /* 567 - "StructUnionGroupGroup" */ + /* 577 - "StructUnionGroupGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 38, 1, 628), Trans(0, 111, 2, 629)], + transitions: &[Trans(0, 39, 1, 637), Trans(0, 112, 2, 638)], k: 1, }, - /* 568 - "StructUnionGroupList" */ + /* 578 - "StructUnionGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 630), - Trans(0, 38, 2, 631), - Trans(0, 111, 2, 631), + Trans(0, 36, 1, 639), + Trans(0, 39, 2, 640), + Trans(0, 112, 2, 640), ], k: 1, }, - /* 569 - "StructUnionItem" */ + /* 579 - "StructUnionItem" */ LookaheadDFA { - prod0: 632, + prod0: 641, transitions: &[], k: 0, }, - /* 570 - "StructUnionList" */ + /* 580 - "StructUnionList" */ LookaheadDFA { - prod0: 622, + prod0: 631, transitions: &[], k: 0, }, - /* 571 - "StructUnionListList" */ + /* 581 - "StructUnionListList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 7, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 7, -1), Trans(1, 5, 6, -1), - Trans(1, 35, 2, -1), - Trans(1, 38, 4, -1), - Trans(1, 42, 20, -1), - Trans(1, 111, 5, -1), - Trans(2, 5, 3, 623), - Trans(2, 39, 3, 623), - Trans(4, 5, 3, 623), - Trans(4, 35, 3, 623), - Trans(4, 38, 3, 623), - Trans(4, 111, 3, 623), - Trans(5, 5, 3, 623), - Trans(5, 29, 3, 623), - Trans(6, 35, 3, 623), - Trans(6, 38, 3, 623), - Trans(6, 42, 19, 624), - Trans(6, 111, 3, 623), + Trans(1, 36, 2, -1), + Trans(1, 39, 4, -1), + Trans(1, 43, 20, -1), + Trans(1, 112, 5, -1), + Trans(2, 5, 3, 632), + Trans(2, 40, 3, 632), + Trans(4, 5, 3, 632), + Trans(4, 36, 3, 632), + Trans(4, 39, 3, 632), + Trans(4, 112, 3, 632), + Trans(5, 5, 3, 632), + Trans(5, 30, 3, 632), + Trans(6, 36, 3, 632), + Trans(6, 39, 3, 632), + Trans(6, 43, 19, 633), + Trans(6, 112, 3, 632), Trans(7, 5, 8, -1), - Trans(7, 29, 9, -1), - Trans(7, 30, 10, -1), - Trans(7, 35, 11, -1), - Trans(7, 38, 12, -1), - Trans(7, 42, 13, -1), - Trans(7, 47, 14, -1), - Trans(7, 48, 15, -1), - Trans(7, 49, 9, -1), - Trans(7, 59, 9, -1), - Trans(7, 60, 16, -1), - Trans(7, 63, 14, -1), - Trans(7, 64, 9, -1), + Trans(7, 30, 9, -1), + Trans(7, 31, 10, -1), + Trans(7, 36, 11, -1), + Trans(7, 39, 12, -1), + Trans(7, 43, 13, -1), + Trans(7, 48, 14, -1), + Trans(7, 49, 15, -1), + Trans(7, 50, 9, -1), + Trans(7, 60, 9, -1), + Trans(7, 61, 16, -1), + Trans(7, 64, 14, -1), Trans(7, 65, 9, -1), - Trans(7, 69, 17, -1), - Trans(7, 70, 18, -1), - Trans(7, 72, 14, -1), - Trans(7, 76, 9, -1), - Trans(7, 79, 9, -1), + Trans(7, 66, 9, -1), + Trans(7, 70, 17, -1), + Trans(7, 71, 18, -1), + Trans(7, 73, 14, -1), + Trans(7, 77, 9, -1), Trans(7, 80, 9, -1), - Trans(7, 83, 9, -1), - Trans(7, 103, 9, -1), - Trans(7, 105, 9, -1), - Trans(7, 108, 9, -1), + Trans(7, 81, 9, -1), + Trans(7, 84, 9, -1), + Trans(7, 104, 9, -1), + Trans(7, 106, 9, -1), Trans(7, 109, 9, -1), - Trans(8, 29, 19, 624), - Trans(8, 30, 19, 624), - Trans(8, 35, 19, 624), - Trans(8, 38, 19, 624), - Trans(8, 42, 19, 624), - Trans(8, 47, 19, 624), - Trans(8, 48, 19, 624), - Trans(8, 49, 19, 624), - Trans(8, 59, 19, 624), - Trans(8, 60, 19, 624), - Trans(8, 63, 19, 624), - Trans(8, 64, 19, 624), - Trans(8, 65, 19, 624), - Trans(8, 69, 19, 624), - Trans(8, 70, 19, 624), - Trans(8, 72, 19, 624), - Trans(8, 76, 19, 624), - Trans(8, 79, 19, 624), - Trans(8, 80, 19, 624), - Trans(8, 83, 19, 624), - Trans(8, 103, 19, 624), - Trans(8, 105, 19, 624), - Trans(8, 108, 19, 624), - Trans(8, 109, 19, 624), - Trans(9, 5, 19, 624), - Trans(9, 111, 19, 624), - Trans(10, 5, 19, 624), - Trans(10, 35, 19, 624), - Trans(10, 38, 19, 624), - Trans(10, 42, 19, 624), - Trans(10, 111, 19, 624), - Trans(11, 5, 19, 624), - Trans(11, 39, 19, 624), - Trans(12, 5, 19, 624), - Trans(12, 29, 19, 624), - Trans(12, 35, 19, 624), - Trans(12, 38, 19, 624), - Trans(12, 42, 19, 624), - Trans(12, 47, 19, 624), - Trans(12, 48, 19, 624), - Trans(12, 49, 19, 624), - Trans(12, 59, 19, 624), - Trans(12, 60, 19, 624), - Trans(12, 63, 19, 624), - Trans(12, 64, 19, 624), - Trans(12, 65, 19, 624), - Trans(12, 69, 19, 624), - Trans(12, 70, 19, 624), - Trans(12, 72, 19, 624), - Trans(12, 76, 19, 624), - Trans(12, 79, 19, 624), - Trans(12, 80, 19, 624), - Trans(12, 83, 19, 624), - Trans(12, 103, 19, 624), - Trans(12, 105, 19, 624), - Trans(12, 108, 19, 624), - Trans(12, 109, 19, 624), - Trans(13, 0, 19, 624), - Trans(13, 5, 19, 624), - Trans(13, 29, 19, 624), - Trans(13, 30, 19, 624), - Trans(13, 35, 19, 624), - Trans(13, 38, 19, 624), - Trans(13, 42, 19, 624), - Trans(13, 47, 19, 624), - Trans(13, 48, 19, 624), - Trans(13, 49, 19, 624), - Trans(13, 57, 19, 624), - Trans(13, 58, 19, 624), - Trans(13, 59, 19, 624), - Trans(13, 60, 19, 624), - Trans(13, 63, 19, 624), - Trans(13, 64, 19, 624), - Trans(13, 65, 19, 624), - Trans(13, 69, 19, 624), - Trans(13, 70, 19, 624), - Trans(13, 71, 19, 624), - Trans(13, 72, 19, 624), - Trans(13, 76, 19, 624), - Trans(13, 77, 19, 624), - Trans(13, 79, 19, 624), - Trans(13, 80, 19, 624), - Trans(13, 83, 19, 624), - Trans(13, 84, 19, 624), - Trans(13, 88, 19, 624), - Trans(13, 90, 19, 624), - Trans(13, 103, 19, 624), - Trans(13, 105, 19, 624), - Trans(13, 108, 19, 624), - Trans(13, 109, 19, 624), - Trans(14, 5, 19, 624), - Trans(14, 38, 19, 624), - Trans(15, 5, 19, 624), - Trans(15, 40, 19, 624), - Trans(16, 5, 19, 624), - Trans(16, 46, 19, 624), - Trans(16, 110, 19, 624), - Trans(16, 111, 19, 624), - Trans(17, 5, 19, 624), - Trans(17, 6, 19, 624), - Trans(17, 7, 19, 624), - Trans(17, 8, 19, 624), - Trans(17, 9, 19, 624), - Trans(17, 10, 19, 624), - Trans(17, 11, 19, 624), - Trans(17, 18, 19, 624), - Trans(17, 24, 19, 624), - Trans(17, 25, 19, 624), - Trans(17, 26, 19, 624), - Trans(17, 27, 19, 624), - Trans(17, 37, 19, 624), - Trans(17, 38, 19, 624), - Trans(17, 40, 19, 624), - Trans(17, 52, 19, 624), - Trans(17, 69, 19, 624), - Trans(17, 75, 19, 624), - Trans(17, 82, 19, 624), - Trans(17, 85, 19, 624), - Trans(17, 87, 19, 624), - Trans(17, 110, 19, 624), - Trans(17, 111, 19, 624), - Trans(18, 5, 19, 624), - Trans(18, 110, 19, 624), - Trans(18, 111, 19, 624), - Trans(20, 5, 19, 624), - Trans(20, 29, 19, 624), - Trans(20, 30, 19, 624), - Trans(20, 35, 19, 624), - Trans(20, 38, 19, 624), - Trans(20, 42, 19, 624), - Trans(20, 47, 19, 624), - Trans(20, 48, 19, 624), - Trans(20, 49, 19, 624), - Trans(20, 59, 19, 624), - Trans(20, 60, 19, 624), - Trans(20, 63, 19, 624), - Trans(20, 64, 19, 624), - Trans(20, 65, 19, 624), - Trans(20, 69, 19, 624), - Trans(20, 70, 19, 624), - Trans(20, 72, 19, 624), - Trans(20, 76, 19, 624), - Trans(20, 79, 19, 624), - Trans(20, 80, 19, 624), - Trans(20, 83, 19, 624), - Trans(20, 103, 19, 624), - Trans(20, 105, 19, 624), - Trans(20, 108, 19, 624), - Trans(20, 109, 19, 624), + Trans(7, 110, 9, -1), + Trans(8, 30, 19, 633), + Trans(8, 31, 19, 633), + Trans(8, 36, 19, 633), + Trans(8, 39, 19, 633), + Trans(8, 43, 19, 633), + Trans(8, 48, 19, 633), + Trans(8, 49, 19, 633), + Trans(8, 50, 19, 633), + Trans(8, 60, 19, 633), + Trans(8, 61, 19, 633), + Trans(8, 64, 19, 633), + Trans(8, 65, 19, 633), + Trans(8, 66, 19, 633), + Trans(8, 70, 19, 633), + Trans(8, 71, 19, 633), + Trans(8, 73, 19, 633), + Trans(8, 77, 19, 633), + Trans(8, 80, 19, 633), + Trans(8, 81, 19, 633), + Trans(8, 84, 19, 633), + Trans(8, 104, 19, 633), + Trans(8, 106, 19, 633), + Trans(8, 109, 19, 633), + Trans(8, 110, 19, 633), + Trans(9, 5, 19, 633), + Trans(9, 112, 19, 633), + Trans(10, 5, 19, 633), + Trans(10, 36, 19, 633), + Trans(10, 39, 19, 633), + Trans(10, 43, 19, 633), + Trans(10, 112, 19, 633), + Trans(11, 5, 19, 633), + Trans(11, 40, 19, 633), + Trans(12, 5, 19, 633), + Trans(12, 30, 19, 633), + Trans(12, 36, 19, 633), + Trans(12, 39, 19, 633), + Trans(12, 43, 19, 633), + Trans(12, 48, 19, 633), + Trans(12, 49, 19, 633), + Trans(12, 50, 19, 633), + Trans(12, 60, 19, 633), + Trans(12, 61, 19, 633), + Trans(12, 64, 19, 633), + Trans(12, 65, 19, 633), + Trans(12, 66, 19, 633), + Trans(12, 70, 19, 633), + Trans(12, 71, 19, 633), + Trans(12, 73, 19, 633), + Trans(12, 77, 19, 633), + Trans(12, 80, 19, 633), + Trans(12, 81, 19, 633), + Trans(12, 84, 19, 633), + Trans(12, 104, 19, 633), + Trans(12, 106, 19, 633), + Trans(12, 109, 19, 633), + Trans(12, 110, 19, 633), + Trans(13, 0, 19, 633), + Trans(13, 5, 19, 633), + Trans(13, 30, 19, 633), + Trans(13, 31, 19, 633), + Trans(13, 36, 19, 633), + Trans(13, 39, 19, 633), + Trans(13, 43, 19, 633), + Trans(13, 48, 19, 633), + Trans(13, 49, 19, 633), + Trans(13, 50, 19, 633), + Trans(13, 58, 19, 633), + Trans(13, 59, 19, 633), + Trans(13, 60, 19, 633), + Trans(13, 61, 19, 633), + Trans(13, 64, 19, 633), + Trans(13, 65, 19, 633), + Trans(13, 66, 19, 633), + Trans(13, 70, 19, 633), + Trans(13, 71, 19, 633), + Trans(13, 72, 19, 633), + Trans(13, 73, 19, 633), + Trans(13, 77, 19, 633), + Trans(13, 78, 19, 633), + Trans(13, 80, 19, 633), + Trans(13, 81, 19, 633), + Trans(13, 84, 19, 633), + Trans(13, 85, 19, 633), + Trans(13, 89, 19, 633), + Trans(13, 91, 19, 633), + Trans(13, 104, 19, 633), + Trans(13, 106, 19, 633), + Trans(13, 109, 19, 633), + Trans(13, 110, 19, 633), + Trans(14, 5, 19, 633), + Trans(14, 39, 19, 633), + Trans(15, 5, 19, 633), + Trans(15, 41, 19, 633), + Trans(16, 5, 19, 633), + Trans(16, 47, 19, 633), + Trans(16, 111, 19, 633), + Trans(16, 112, 19, 633), + Trans(17, 5, 19, 633), + Trans(17, 6, 19, 633), + Trans(17, 7, 19, 633), + Trans(17, 8, 19, 633), + Trans(17, 9, 19, 633), + Trans(17, 10, 19, 633), + Trans(17, 11, 19, 633), + Trans(17, 18, 19, 633), + Trans(17, 24, 19, 633), + Trans(17, 25, 19, 633), + Trans(17, 26, 19, 633), + Trans(17, 27, 19, 633), + Trans(17, 38, 19, 633), + Trans(17, 39, 19, 633), + Trans(17, 41, 19, 633), + Trans(17, 53, 19, 633), + Trans(17, 70, 19, 633), + Trans(17, 76, 19, 633), + Trans(17, 83, 19, 633), + Trans(17, 86, 19, 633), + Trans(17, 88, 19, 633), + Trans(17, 111, 19, 633), + Trans(17, 112, 19, 633), + Trans(18, 5, 19, 633), + Trans(18, 111, 19, 633), + Trans(18, 112, 19, 633), + Trans(20, 5, 19, 633), + Trans(20, 30, 19, 633), + Trans(20, 31, 19, 633), + Trans(20, 36, 19, 633), + Trans(20, 39, 19, 633), + Trans(20, 43, 19, 633), + Trans(20, 48, 19, 633), + Trans(20, 49, 19, 633), + Trans(20, 50, 19, 633), + Trans(20, 60, 19, 633), + Trans(20, 61, 19, 633), + Trans(20, 64, 19, 633), + Trans(20, 65, 19, 633), + Trans(20, 66, 19, 633), + Trans(20, 70, 19, 633), + Trans(20, 71, 19, 633), + Trans(20, 73, 19, 633), + Trans(20, 77, 19, 633), + Trans(20, 80, 19, 633), + Trans(20, 81, 19, 633), + Trans(20, 84, 19, 633), + Trans(20, 104, 19, 633), + Trans(20, 106, 19, 633), + Trans(20, 109, 19, 633), + Trans(20, 110, 19, 633), ], k: 3, }, - /* 572 - "StructUnionListOpt" */ + /* 582 - "StructUnionListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 625), Trans(0, 42, 2, 626)], + transitions: &[Trans(0, 31, 1, 634), Trans(0, 43, 2, 635)], k: 1, }, - /* 573 - "Tri" */ + /* 583 - "Tri" */ LookaheadDFA { - prod0: 317, + prod0: 320, transitions: &[], k: 0, }, - /* 574 - "TriTerm" */ + /* 584 - "TriTerm" */ LookaheadDFA { - prod0: 99, + prod0: 100, transitions: &[], k: 0, }, - /* 575 - "TriToken" */ + /* 585 - "TriToken" */ LookaheadDFA { - prod0: 210, + prod0: 212, transitions: &[], k: 0, }, - /* 576 - "Type" */ + /* 586 - "Type" */ LookaheadDFA { - prod0: 318, + prod0: 321, transitions: &[], k: 0, }, - /* 577 - "TypeDefDeclaration" */ + /* 587 - "TypeDefDeclaration" */ LookaheadDFA { - prod0: 581, + prod0: 588, transitions: &[], k: 0, }, - /* 578 - "TypeExpression" */ + /* 588 - "TypeExpression" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 51, 1, 451), - Trans(0, 53, 1, 451), - Trans(0, 54, 1, 451), - Trans(0, 55, 1, 451), - Trans(0, 61, 1, 451), - Trans(0, 62, 1, 451), - Trans(0, 66, 1, 451), - Trans(0, 67, 1, 451), - Trans(0, 81, 1, 451), - Trans(0, 93, 1, 451), - Trans(0, 94, 1, 451), - Trans(0, 95, 1, 451), - Trans(0, 96, 1, 451), - Trans(0, 97, 1, 451), - Trans(0, 100, 1, 451), - Trans(0, 102, 1, 451), - Trans(0, 104, 1, 451), - Trans(0, 105, 2, 452), - Trans(0, 106, 1, 451), - Trans(0, 107, 1, 451), - Trans(0, 110, 1, 451), - Trans(0, 111, 1, 451), + Trans(0, 52, 1, 458), + Trans(0, 54, 1, 458), + Trans(0, 55, 1, 458), + Trans(0, 56, 1, 458), + Trans(0, 62, 1, 458), + Trans(0, 63, 1, 458), + Trans(0, 67, 1, 458), + Trans(0, 68, 1, 458), + Trans(0, 82, 1, 458), + Trans(0, 94, 1, 458), + Trans(0, 95, 1, 458), + Trans(0, 96, 1, 458), + Trans(0, 97, 1, 458), + Trans(0, 98, 1, 458), + Trans(0, 101, 1, 458), + Trans(0, 103, 1, 458), + Trans(0, 105, 1, 458), + Trans(0, 106, 2, 459), + Trans(0, 107, 1, 458), + Trans(0, 108, 1, 458), + Trans(0, 111, 1, 458), + Trans(0, 112, 1, 458), ], k: 1, }, - /* 579 - "TypeModifier" */ + /* 589 - "TypeModifier" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 100, 2, 501), Trans(0, 104, 1, 500)], + transitions: &[Trans(0, 101, 2, 508), Trans(0, 105, 1, 507)], k: 1, }, - /* 580 - "TypeTerm" */ + /* 590 - "TypeTerm" */ LookaheadDFA { - prod0: 100, + prod0: 101, transitions: &[], k: 0, }, - /* 581 - "TypeToken" */ + /* 591 - "TypeToken" */ LookaheadDFA { - prod0: 211, + prod0: 213, transitions: &[], k: 0, }, - /* 582 - "U32" */ + /* 592 - "U32" */ LookaheadDFA { - prod0: 319, + prod0: 322, transitions: &[], k: 0, }, - /* 583 - "U32Term" */ + /* 593 - "U32Term" */ LookaheadDFA { - prod0: 101, + prod0: 102, transitions: &[], k: 0, }, - /* 584 - "U32Token" */ + /* 594 - "U32Token" */ LookaheadDFA { - prod0: 212, + prod0: 214, transitions: &[], k: 0, }, - /* 585 - "U64" */ + /* 595 - "U64" */ LookaheadDFA { - prod0: 320, + prod0: 323, transitions: &[], k: 0, }, - /* 586 - "U64Term" */ + /* 596 - "U64Term" */ LookaheadDFA { - prod0: 102, + prod0: 103, transitions: &[], k: 0, }, - /* 587 - "U64Token" */ + /* 597 - "U64Token" */ LookaheadDFA { - prod0: 213, + prod0: 215, transitions: &[], k: 0, }, - /* 588 - "UnaryOperator" */ + /* 598 - "UnaryOperator" */ LookaheadDFA { - prod0: 237, + prod0: 239, transitions: &[], k: 0, }, - /* 589 - "UnaryOperatorTerm" */ + /* 599 - "UnaryOperatorTerm" */ LookaheadDFA { prod0: 22, transitions: &[], k: 0, }, - /* 590 - "UnaryOperatorToken" */ + /* 600 - "UnaryOperatorToken" */ LookaheadDFA { - prod0: 130, + prod0: 131, transitions: &[], k: 0, }, - /* 591 - "Union" */ + /* 601 - "Union" */ LookaheadDFA { - prod0: 321, + prod0: 324, transitions: &[], k: 0, }, - /* 592 - "UnionTerm" */ + /* 602 - "UnionTerm" */ LookaheadDFA { - prod0: 103, + prod0: 104, transitions: &[], k: 0, }, - /* 593 - "UnionToken" */ + /* 603 - "UnionToken" */ LookaheadDFA { - prod0: 214, + prod0: 216, transitions: &[], k: 0, }, - /* 594 - "Var" */ + /* 604 - "Var" */ LookaheadDFA { - prod0: 322, + prod0: 325, transitions: &[], k: 0, }, - /* 595 - "VarDeclaration" */ + /* 605 - "VarDeclaration" */ LookaheadDFA { - prod0: 577, + prod0: 584, transitions: &[], k: 0, }, - /* 596 - "VarTerm" */ + /* 606 - "VarTerm" */ LookaheadDFA { - prod0: 104, + prod0: 105, transitions: &[], k: 0, }, - /* 597 - "VarToken" */ + /* 607 - "VarToken" */ LookaheadDFA { - prod0: 215, + prod0: 217, transitions: &[], k: 0, }, - /* 598 - "VariableType" */ + /* 608 - "VariableType" */ LookaheadDFA { - prod0: 486, + prod0: 493, transitions: &[], k: 0, }, - /* 599 - "VariableTypeGroup" */ + /* 609 - "VariableTypeGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 51, 10, 496), - Trans(0, 53, 1, 487), - Trans(0, 54, 2, 488), - Trans(0, 55, 3, 489), - Trans(0, 81, 9, 495), - Trans(0, 93, 4, 490), - Trans(0, 94, 5, 491), - Trans(0, 95, 6, 492), - Trans(0, 96, 7, 493), - Trans(0, 97, 8, 494), - Trans(0, 110, 11, 497), - Trans(0, 111, 11, 497), + Trans(0, 52, 10, 503), + Trans(0, 54, 1, 494), + Trans(0, 55, 2, 495), + Trans(0, 56, 3, 496), + Trans(0, 82, 9, 502), + Trans(0, 94, 4, 497), + Trans(0, 95, 5, 498), + Trans(0, 96, 6, 499), + Trans(0, 97, 7, 500), + Trans(0, 98, 8, 501), + Trans(0, 111, 11, 504), + Trans(0, 112, 11, 504), ], k: 1, }, - /* 600 - "VariableTypeOpt" */ + /* 610 - "VariableTypeOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 2, 499), - Trans(0, 34, 2, 499), - Trans(0, 36, 1, 498), - Trans(0, 38, 2, 499), - Trans(0, 39, 2, 499), - Trans(0, 42, 2, 499), - Trans(0, 44, 2, 499), - Trans(0, 45, 2, 499), - Trans(0, 78, 2, 499), + Trans(0, 31, 2, 506), + Trans(0, 35, 2, 506), + Trans(0, 37, 1, 505), + Trans(0, 39, 2, 506), + Trans(0, 40, 2, 506), + Trans(0, 43, 2, 506), + Trans(0, 45, 2, 506), + Trans(0, 46, 2, 506), + Trans(0, 79, 2, 506), ], k: 1, }, - /* 601 - "Veryl" */ + /* 611 - "Veryl" */ LookaheadDFA { - prod0: 873, + prod0: 905, transitions: &[], k: 0, }, - /* 602 - "VerylList" */ + /* 612 - "VerylList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 0, 2, 875), - Trans(0, 35, 1, 874), - Trans(0, 38, 1, 874), - Trans(0, 58, 1, 874), - Trans(0, 70, 1, 874), - Trans(0, 71, 1, 874), - Trans(0, 77, 1, 874), - Trans(0, 84, 1, 874), - Trans(0, 88, 1, 874), - Trans(0, 90, 1, 874), + Trans(0, 0, 2, 907), + Trans(0, 36, 1, 906), + Trans(0, 39, 1, 906), + Trans(0, 59, 1, 906), + Trans(0, 71, 1, 906), + Trans(0, 72, 1, 906), + Trans(0, 78, 1, 906), + Trans(0, 85, 1, 906), + Trans(0, 89, 1, 906), + Trans(0, 91, 1, 906), ], k: 1, }, - /* 603 - "Width" */ + /* 613 - "Width" */ LookaheadDFA { - prod0: 468, + prod0: 475, + transitions: &[], + k: 0, + }, + /* 614 - "WidthList" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 31, 1, 476), Trans(0, 42, 2, 477)], + k: 1, + }, + /* 615 - "WithGenericArgument" */ + LookaheadDFA { + prod0: 711, + transitions: &[], + k: 0, + }, + /* 616 - "WithGenericArgumentItem" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 7, 2, 718), + Trans(0, 8, 2, 718), + Trans(0, 9, 2, 718), + Trans(0, 10, 2, 718), + Trans(0, 11, 2, 718), + Trans(0, 111, 1, 717), + Trans(0, 112, 1, 717), + ], + k: 1, + }, + /* 617 - "WithGenericArgumentList" */ + LookaheadDFA { + prod0: 712, + transitions: &[], + k: 0, + }, + /* 618 - "WithGenericArgumentListList" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 31, 1, -1), + Trans(0, 42, 7, -1), + Trans(1, 5, 6, -1), + Trans(1, 7, 2, -1), + Trans(1, 8, 2, -1), + Trans(1, 9, 2, -1), + Trans(1, 10, 2, -1), + Trans(1, 11, 2, -1), + Trans(1, 42, 17, -1), + Trans(1, 111, 4, -1), + Trans(1, 112, 5, -1), + Trans(2, 5, 3, 713), + Trans(2, 31, 3, 713), + Trans(2, 42, 3, 713), + Trans(4, 5, 3, 713), + Trans(4, 29, 3, 713), + Trans(4, 31, 3, 713), + Trans(4, 42, 3, 713), + Trans(5, 5, 3, 713), + Trans(5, 28, 3, 713), + Trans(5, 29, 3, 713), + Trans(5, 31, 3, 713), + Trans(5, 42, 3, 713), + Trans(6, 7, 3, 713), + Trans(6, 8, 3, 713), + Trans(6, 9, 3, 713), + Trans(6, 10, 3, 713), + Trans(6, 11, 3, 713), + Trans(6, 42, 24, 714), + Trans(6, 111, 3, 713), + Trans(6, 112, 3, 713), + Trans(7, 5, 8, -1), + Trans(7, 12, 9, -1), + Trans(7, 14, 9, -1), + Trans(7, 15, 9, -1), + Trans(7, 16, 9, -1), + Trans(7, 17, 9, -1), + Trans(7, 18, 9, -1), + Trans(7, 19, 9, -1), + Trans(7, 20, 9, -1), + Trans(7, 21, 9, -1), + Trans(7, 22, 9, -1), + Trans(7, 23, 9, -1), + Trans(7, 24, 9, -1), + Trans(7, 25, 9, -1), + Trans(7, 26, 9, -1), + Trans(7, 29, 10, -1), + Trans(7, 30, 11, -1), + Trans(7, 31, 12, -1), + Trans(7, 32, 9, -1), + Trans(7, 33, 9, -1), + Trans(7, 34, 13, -1), + Trans(7, 35, 9, -1), + Trans(7, 36, 14, -1), + Trans(7, 37, 9, -1), + Trans(7, 39, 15, -1), + Trans(7, 40, 9, -1), + Trans(7, 41, 16, -1), + Trans(7, 42, 17, -1), + Trans(7, 43, 18, -1), + Trans(7, 44, 19, -1), + Trans(7, 45, 20, -1), + Trans(7, 46, 21, -1), + Trans(7, 47, 9, -1), + Trans(7, 51, 22, -1), + Trans(7, 79, 9, -1), + Trans(7, 93, 9, -1), + Trans(7, 102, 23, -1), + Trans(8, 12, 24, 714), + Trans(8, 14, 24, 714), + Trans(8, 15, 24, 714), + Trans(8, 16, 24, 714), + Trans(8, 17, 24, 714), + Trans(8, 18, 24, 714), + Trans(8, 19, 24, 714), + Trans(8, 20, 24, 714), + Trans(8, 21, 24, 714), + Trans(8, 22, 24, 714), + Trans(8, 23, 24, 714), + Trans(8, 24, 24, 714), + Trans(8, 25, 24, 714), + Trans(8, 26, 24, 714), + Trans(8, 29, 24, 714), + Trans(8, 30, 24, 714), + Trans(8, 31, 24, 714), + Trans(8, 32, 24, 714), + Trans(8, 33, 24, 714), + Trans(8, 34, 24, 714), + Trans(8, 35, 24, 714), + Trans(8, 36, 24, 714), + Trans(8, 37, 24, 714), + Trans(8, 39, 24, 714), + Trans(8, 40, 24, 714), + Trans(8, 41, 24, 714), + Trans(8, 42, 24, 714), + Trans(8, 43, 24, 714), + Trans(8, 44, 24, 714), + Trans(8, 45, 24, 714), + Trans(8, 46, 24, 714), + Trans(8, 47, 24, 714), + Trans(8, 51, 24, 714), + Trans(8, 79, 24, 714), + Trans(8, 93, 24, 714), + Trans(8, 102, 24, 714), + Trans(9, 5, 24, 714), + Trans(9, 6, 24, 714), + Trans(9, 7, 24, 714), + Trans(9, 8, 24, 714), + Trans(9, 9, 24, 714), + Trans(9, 10, 24, 714), + Trans(9, 11, 24, 714), + Trans(9, 18, 24, 714), + Trans(9, 24, 24, 714), + Trans(9, 25, 24, 714), + Trans(9, 26, 24, 714), + Trans(9, 27, 24, 714), + Trans(9, 38, 24, 714), + Trans(9, 39, 24, 714), + Trans(9, 41, 24, 714), + Trans(9, 53, 24, 714), + Trans(9, 70, 24, 714), + Trans(9, 76, 24, 714), + Trans(9, 83, 24, 714), + Trans(9, 86, 24, 714), + Trans(9, 88, 24, 714), + Trans(9, 111, 24, 714), + Trans(9, 112, 24, 714), + Trans(10, 5, 24, 714), + Trans(10, 47, 24, 714), + Trans(10, 112, 24, 714), + Trans(11, 5, 24, 714), + Trans(11, 6, 24, 714), + Trans(11, 7, 24, 714), + Trans(11, 8, 24, 714), + Trans(11, 9, 24, 714), + Trans(11, 10, 24, 714), + Trans(11, 11, 24, 714), + Trans(11, 18, 24, 714), + Trans(11, 24, 24, 714), + Trans(11, 25, 24, 714), + Trans(11, 26, 24, 714), + Trans(11, 27, 24, 714), + Trans(11, 38, 24, 714), + Trans(11, 39, 24, 714), + Trans(11, 41, 24, 714), + Trans(11, 53, 24, 714), + Trans(11, 65, 24, 714), + Trans(11, 69, 24, 714), + Trans(11, 70, 24, 714), + Trans(11, 76, 24, 714), + Trans(11, 80, 24, 714), + Trans(11, 83, 24, 714), + Trans(11, 86, 24, 714), + Trans(11, 88, 24, 714), + Trans(11, 99, 24, 714), + Trans(11, 100, 24, 714), + Trans(11, 111, 24, 714), + Trans(11, 112, 24, 714), + Trans(12, 5, 24, 714), + Trans(12, 6, 24, 714), + Trans(12, 7, 24, 714), + Trans(12, 8, 24, 714), + Trans(12, 9, 24, 714), + Trans(12, 10, 24, 714), + Trans(12, 11, 24, 714), + Trans(12, 18, 24, 714), + Trans(12, 24, 24, 714), + Trans(12, 25, 24, 714), + Trans(12, 26, 24, 714), + Trans(12, 27, 24, 714), + Trans(12, 36, 24, 714), + Trans(12, 38, 24, 714), + Trans(12, 39, 24, 714), + Trans(12, 41, 24, 714), + Trans(12, 42, 24, 714), + Trans(12, 43, 24, 714), + Trans(12, 45, 24, 714), + Trans(12, 53, 24, 714), + Trans(12, 57, 24, 714), + Trans(12, 70, 24, 714), + Trans(12, 76, 24, 714), + Trans(12, 81, 24, 714), + Trans(12, 83, 24, 714), + Trans(12, 86, 24, 714), + Trans(12, 88, 24, 714), + Trans(12, 90, 24, 714), + Trans(12, 111, 24, 714), + Trans(12, 112, 24, 714), + Trans(13, 5, 24, 714), + Trans(13, 112, 24, 714), + Trans(14, 5, 24, 714), + Trans(14, 41, 24, 714), + Trans(15, 5, 24, 714), + Trans(15, 6, 24, 714), + Trans(15, 7, 24, 714), + Trans(15, 8, 24, 714), + Trans(15, 9, 24, 714), + Trans(15, 10, 24, 714), + Trans(15, 11, 24, 714), + Trans(15, 18, 24, 714), + Trans(15, 24, 24, 714), + Trans(15, 25, 24, 714), + Trans(15, 26, 24, 714), + Trans(15, 27, 24, 714), + Trans(15, 30, 24, 714), + Trans(15, 36, 24, 714), + Trans(15, 38, 24, 714), + Trans(15, 39, 24, 714), + Trans(15, 41, 24, 714), + Trans(15, 43, 24, 714), + Trans(15, 48, 24, 714), + Trans(15, 49, 24, 714), + Trans(15, 50, 24, 714), + Trans(15, 53, 24, 714), + Trans(15, 57, 24, 714), + Trans(15, 60, 24, 714), + Trans(15, 64, 24, 714), + Trans(15, 65, 24, 714), + Trans(15, 66, 24, 714), + Trans(15, 69, 24, 714), + Trans(15, 70, 24, 714), + Trans(15, 71, 24, 714), + Trans(15, 73, 24, 714), + Trans(15, 76, 24, 714), + Trans(15, 77, 24, 714), + Trans(15, 80, 24, 714), + Trans(15, 81, 24, 714), + Trans(15, 83, 24, 714), + Trans(15, 84, 24, 714), + Trans(15, 86, 24, 714), + Trans(15, 88, 24, 714), + Trans(15, 99, 24, 714), + Trans(15, 100, 24, 714), + Trans(15, 104, 24, 714), + Trans(15, 106, 24, 714), + Trans(15, 109, 24, 714), + Trans(15, 110, 24, 714), + Trans(15, 111, 24, 714), + Trans(15, 112, 24, 714), + Trans(16, 5, 24, 714), + Trans(16, 6, 24, 714), + Trans(16, 7, 24, 714), + Trans(16, 8, 24, 714), + Trans(16, 9, 24, 714), + Trans(16, 10, 24, 714), + Trans(16, 11, 24, 714), + Trans(16, 18, 24, 714), + Trans(16, 24, 24, 714), + Trans(16, 25, 24, 714), + Trans(16, 26, 24, 714), + Trans(16, 27, 24, 714), + Trans(16, 36, 24, 714), + Trans(16, 38, 24, 714), + Trans(16, 39, 24, 714), + Trans(16, 41, 24, 714), + Trans(16, 45, 24, 714), + Trans(16, 53, 24, 714), + Trans(16, 70, 24, 714), + Trans(16, 76, 24, 714), + Trans(16, 83, 24, 714), + Trans(16, 86, 24, 714), + Trans(16, 88, 24, 714), + Trans(16, 111, 24, 714), + Trans(16, 112, 24, 714), + Trans(17, 5, 24, 714), + Trans(17, 12, 24, 714), + Trans(17, 14, 24, 714), + Trans(17, 15, 24, 714), + Trans(17, 16, 24, 714), + Trans(17, 17, 24, 714), + Trans(17, 18, 24, 714), + Trans(17, 19, 24, 714), + Trans(17, 20, 24, 714), + Trans(17, 21, 24, 714), + Trans(17, 22, 24, 714), + Trans(17, 23, 24, 714), + Trans(17, 24, 24, 714), + Trans(17, 25, 24, 714), + Trans(17, 26, 24, 714), + Trans(17, 29, 24, 714), + Trans(17, 30, 24, 714), + Trans(17, 31, 24, 714), + Trans(17, 32, 24, 714), + Trans(17, 33, 24, 714), + Trans(17, 34, 24, 714), + Trans(17, 35, 24, 714), + Trans(17, 36, 24, 714), + Trans(17, 37, 24, 714), + Trans(17, 39, 24, 714), + Trans(17, 40, 24, 714), + Trans(17, 41, 24, 714), + Trans(17, 42, 24, 714), + Trans(17, 43, 24, 714), + Trans(17, 44, 24, 714), + Trans(17, 45, 24, 714), + Trans(17, 46, 24, 714), + Trans(17, 47, 24, 714), + Trans(17, 51, 24, 714), + Trans(17, 79, 24, 714), + Trans(17, 93, 24, 714), + Trans(17, 102, 24, 714), + Trans(18, 5, 24, 714), + Trans(18, 12, 24, 714), + Trans(18, 14, 24, 714), + Trans(18, 16, 24, 714), + Trans(18, 17, 24, 714), + Trans(18, 18, 24, 714), + Trans(18, 19, 24, 714), + Trans(18, 20, 24, 714), + Trans(18, 21, 24, 714), + Trans(18, 22, 24, 714), + Trans(18, 23, 24, 714), + Trans(18, 24, 24, 714), + Trans(18, 25, 24, 714), + Trans(18, 26, 24, 714), + Trans(18, 30, 24, 714), + Trans(18, 31, 24, 714), + Trans(18, 32, 24, 714), + Trans(18, 33, 24, 714), + Trans(18, 36, 24, 714), + Trans(18, 39, 24, 714), + Trans(18, 42, 24, 714), + Trans(18, 43, 24, 714), + Trans(18, 44, 24, 714), + Trans(18, 45, 24, 714), + Trans(18, 46, 24, 714), + Trans(18, 47, 24, 714), + Trans(18, 48, 24, 714), + Trans(18, 49, 24, 714), + Trans(18, 50, 24, 714), + Trans(18, 51, 24, 714), + Trans(18, 58, 24, 714), + Trans(18, 60, 24, 714), + Trans(18, 61, 24, 714), + Trans(18, 64, 24, 714), + Trans(18, 65, 24, 714), + Trans(18, 66, 24, 714), + Trans(18, 70, 24, 714), + Trans(18, 71, 24, 714), + Trans(18, 73, 24, 714), + Trans(18, 77, 24, 714), + Trans(18, 80, 24, 714), + Trans(18, 81, 24, 714), + Trans(18, 84, 24, 714), + Trans(18, 93, 24, 714), + Trans(18, 102, 24, 714), + Trans(18, 104, 24, 714), + Trans(18, 106, 24, 714), + Trans(18, 109, 24, 714), + Trans(18, 110, 24, 714), + Trans(19, 5, 24, 714), + Trans(19, 12, 24, 714), + Trans(19, 14, 24, 714), + Trans(19, 15, 24, 714), + Trans(19, 16, 24, 714), + Trans(19, 17, 24, 714), + Trans(19, 18, 24, 714), + Trans(19, 19, 24, 714), + Trans(19, 20, 24, 714), + Trans(19, 21, 24, 714), + Trans(19, 22, 24, 714), + Trans(19, 23, 24, 714), + Trans(19, 24, 24, 714), + Trans(19, 25, 24, 714), + Trans(19, 26, 24, 714), + Trans(19, 30, 24, 714), + Trans(19, 31, 24, 714), + Trans(19, 32, 24, 714), + Trans(19, 33, 24, 714), + Trans(19, 34, 24, 714), + Trans(19, 35, 24, 714), + Trans(19, 36, 24, 714), + Trans(19, 39, 24, 714), + Trans(19, 40, 24, 714), + Trans(19, 41, 24, 714), + Trans(19, 42, 24, 714), + Trans(19, 43, 24, 714), + Trans(19, 44, 24, 714), + Trans(19, 45, 24, 714), + Trans(19, 46, 24, 714), + Trans(19, 47, 24, 714), + Trans(19, 51, 24, 714), + Trans(19, 93, 24, 714), + Trans(19, 102, 24, 714), + Trans(20, 5, 24, 714), + Trans(20, 12, 24, 714), + Trans(20, 13, 24, 714), + Trans(20, 14, 24, 714), + Trans(20, 16, 24, 714), + Trans(20, 17, 24, 714), + Trans(20, 18, 24, 714), + Trans(20, 19, 24, 714), + Trans(20, 20, 24, 714), + Trans(20, 21, 24, 714), + Trans(20, 22, 24, 714), + Trans(20, 23, 24, 714), + Trans(20, 24, 24, 714), + Trans(20, 25, 24, 714), + Trans(20, 26, 24, 714), + Trans(20, 30, 24, 714), + Trans(20, 31, 24, 714), + Trans(20, 32, 24, 714), + Trans(20, 33, 24, 714), + Trans(20, 39, 24, 714), + Trans(20, 41, 24, 714), + Trans(20, 42, 24, 714), + Trans(20, 43, 24, 714), + Trans(20, 44, 24, 714), + Trans(20, 45, 24, 714), + Trans(20, 46, 24, 714), + Trans(20, 47, 24, 714), + Trans(20, 51, 24, 714), + Trans(20, 93, 24, 714), + Trans(20, 102, 24, 714), + Trans(21, 0, 24, 714), + Trans(21, 5, 24, 714), + Trans(21, 6, 24, 714), + Trans(21, 7, 24, 714), + Trans(21, 8, 24, 714), + Trans(21, 9, 24, 714), + Trans(21, 10, 24, 714), + Trans(21, 11, 24, 714), + Trans(21, 18, 24, 714), + Trans(21, 24, 24, 714), + Trans(21, 25, 24, 714), + Trans(21, 26, 24, 714), + Trans(21, 27, 24, 714), + Trans(21, 30, 24, 714), + Trans(21, 36, 24, 714), + Trans(21, 38, 24, 714), + Trans(21, 39, 24, 714), + Trans(21, 41, 24, 714), + Trans(21, 43, 24, 714), + Trans(21, 48, 24, 714), + Trans(21, 49, 24, 714), + Trans(21, 50, 24, 714), + Trans(21, 53, 24, 714), + Trans(21, 57, 24, 714), + Trans(21, 59, 24, 714), + Trans(21, 60, 24, 714), + Trans(21, 61, 24, 714), + Trans(21, 64, 24, 714), + Trans(21, 65, 24, 714), + Trans(21, 66, 24, 714), + Trans(21, 69, 24, 714), + Trans(21, 70, 24, 714), + Trans(21, 71, 24, 714), + Trans(21, 72, 24, 714), + Trans(21, 73, 24, 714), + Trans(21, 76, 24, 714), + Trans(21, 77, 24, 714), + Trans(21, 78, 24, 714), + Trans(21, 80, 24, 714), + Trans(21, 81, 24, 714), + Trans(21, 83, 24, 714), + Trans(21, 84, 24, 714), + Trans(21, 85, 24, 714), + Trans(21, 86, 24, 714), + Trans(21, 88, 24, 714), + Trans(21, 89, 24, 714), + Trans(21, 91, 24, 714), + Trans(21, 99, 24, 714), + Trans(21, 100, 24, 714), + Trans(21, 104, 24, 714), + Trans(21, 106, 24, 714), + Trans(21, 109, 24, 714), + Trans(21, 110, 24, 714), + Trans(21, 111, 24, 714), + Trans(21, 112, 24, 714), + Trans(22, 5, 24, 714), + Trans(22, 111, 24, 714), + Trans(22, 112, 24, 714), + Trans(23, 5, 24, 714), + Trans(23, 6, 24, 714), + Trans(23, 7, 24, 714), + Trans(23, 8, 24, 714), + Trans(23, 9, 24, 714), + Trans(23, 10, 24, 714), + Trans(23, 11, 24, 714), + Trans(23, 15, 24, 714), + Trans(23, 18, 24, 714), + Trans(23, 24, 24, 714), + Trans(23, 25, 24, 714), + Trans(23, 26, 24, 714), + Trans(23, 27, 24, 714), + Trans(23, 38, 24, 714), + Trans(23, 39, 24, 714), + Trans(23, 41, 24, 714), + Trans(23, 53, 24, 714), + Trans(23, 70, 24, 714), + Trans(23, 76, 24, 714), + Trans(23, 83, 24, 714), + Trans(23, 86, 24, 714), + Trans(23, 88, 24, 714), + Trans(23, 111, 24, 714), + Trans(23, 112, 24, 714), + ], + k: 3, + }, + /* 619 - "WithGenericArgumentListOpt" */ + LookaheadDFA { + prod0: -1, + transitions: &[Trans(0, 31, 1, 715), Trans(0, 42, 2, 716)], + k: 1, + }, + /* 620 - "WithGenericParameter" */ + LookaheadDFA { + prod0: 704, + transitions: &[], + k: 0, + }, + /* 621 - "WithGenericParameterItem" */ + LookaheadDFA { + prod0: 710, + transitions: &[], + k: 0, + }, + /* 622 - "WithGenericParameterList" */ + LookaheadDFA { + prod0: 705, transitions: &[], k: 0, }, - /* 604 - "WidthList" */ + /* 623 - "WithGenericParameterListList" */ + LookaheadDFA { + prod0: -1, + transitions: &[ + Trans(0, 31, 1, -1), + Trans(0, 42, 5, -1), + Trans(1, 5, 4, -1), + Trans(1, 42, 12, -1), + Trans(1, 112, 2, -1), + Trans(2, 5, 3, 706), + Trans(2, 31, 3, 706), + Trans(2, 42, 3, 706), + Trans(4, 42, 11, 707), + Trans(4, 112, 3, 706), + Trans(5, 5, 6, -1), + Trans(5, 13, 7, -1), + Trans(5, 36, 8, -1), + Trans(5, 39, 9, -1), + Trans(5, 41, 10, -1), + Trans(6, 13, 11, 707), + Trans(6, 36, 11, 707), + Trans(6, 39, 11, 707), + Trans(6, 41, 11, 707), + Trans(7, 5, 11, 707), + Trans(7, 52, 11, 707), + Trans(7, 54, 11, 707), + Trans(7, 55, 11, 707), + Trans(7, 56, 11, 707), + Trans(7, 62, 11, 707), + Trans(7, 63, 11, 707), + Trans(7, 67, 11, 707), + Trans(7, 68, 11, 707), + Trans(7, 82, 11, 707), + Trans(7, 94, 11, 707), + Trans(7, 95, 11, 707), + Trans(7, 96, 11, 707), + Trans(7, 97, 11, 707), + Trans(7, 98, 11, 707), + Trans(7, 101, 11, 707), + Trans(7, 103, 11, 707), + Trans(7, 105, 11, 707), + Trans(7, 107, 11, 707), + Trans(7, 108, 11, 707), + Trans(7, 111, 11, 707), + Trans(7, 112, 11, 707), + Trans(8, 5, 11, 707), + Trans(8, 41, 11, 707), + Trans(9, 5, 11, 707), + Trans(9, 30, 11, 707), + Trans(9, 36, 11, 707), + Trans(9, 39, 11, 707), + Trans(9, 43, 11, 707), + Trans(9, 48, 11, 707), + Trans(9, 49, 11, 707), + Trans(9, 50, 11, 707), + Trans(9, 53, 11, 707), + Trans(9, 60, 11, 707), + Trans(9, 61, 11, 707), + Trans(9, 64, 11, 707), + Trans(9, 65, 11, 707), + Trans(9, 66, 11, 707), + Trans(9, 69, 11, 707), + Trans(9, 70, 11, 707), + Trans(9, 71, 11, 707), + Trans(9, 73, 11, 707), + Trans(9, 77, 11, 707), + Trans(9, 80, 11, 707), + Trans(9, 81, 11, 707), + Trans(9, 84, 11, 707), + Trans(9, 99, 11, 707), + Trans(9, 100, 11, 707), + Trans(9, 104, 11, 707), + Trans(9, 106, 11, 707), + Trans(9, 109, 11, 707), + Trans(9, 110, 11, 707), + Trans(9, 111, 11, 707), + Trans(9, 112, 11, 707), + Trans(10, 5, 11, 707), + Trans(10, 36, 11, 707), + Trans(10, 39, 11, 707), + Trans(10, 45, 11, 707), + Trans(10, 112, 11, 707), + Trans(12, 5, 11, 707), + Trans(12, 13, 11, 707), + Trans(12, 36, 11, 707), + Trans(12, 39, 11, 707), + Trans(12, 41, 11, 707), + ], + k: 3, + }, + /* 624 - "WithGenericParameterListOpt" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 30, 1, 469), Trans(0, 41, 2, 470)], + transitions: &[Trans(0, 31, 1, 708), Trans(0, 42, 2, 709)], k: 1, }, - /* 605 - "WithParameter" */ + /* 625 - "WithParameter" */ LookaheadDFA { - prod0: 677, + prod0: 686, transitions: &[], k: 0, }, - /* 606 - "WithParameterGroup" */ + /* 626 - "WithParameterGroup" */ LookaheadDFA { - prod0: 685, + prod0: 694, transitions: &[], k: 0, }, - /* 607 - "WithParameterGroupGroup" */ + /* 627 - "WithParameterGroupGroup" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 38, 1, 686), - Trans(0, 80, 2, 687), - Trans(0, 89, 2, 687), + Trans(0, 39, 1, 695), + Trans(0, 81, 2, 696), + Trans(0, 90, 2, 696), ], k: 1, }, - /* 608 - "WithParameterGroupList" */ + /* 628 - "WithParameterGroupList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 688), - Trans(0, 38, 2, 689), - Trans(0, 80, 2, 689), - Trans(0, 89, 2, 689), + Trans(0, 36, 1, 697), + Trans(0, 39, 2, 698), + Trans(0, 81, 2, 698), + Trans(0, 90, 2, 698), ], k: 1, }, - /* 609 - "WithParameterItem" */ + /* 629 - "WithParameterItem" */ LookaheadDFA { - prod0: 690, + prod0: 699, transitions: &[], k: 0, }, - /* 610 - "WithParameterItemGroup" */ + /* 630 - "WithParameterItemGroup" */ LookaheadDFA { prod0: -1, - transitions: &[Trans(0, 80, 2, 694), Trans(0, 89, 1, 693)], + transitions: &[Trans(0, 81, 2, 703), Trans(0, 90, 1, 702)], k: 1, }, - /* 611 - "WithParameterItemGroup0" */ + /* 631 - "WithParameterItemGroup0" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 51, 1, 691), - Trans(0, 53, 1, 691), - Trans(0, 54, 1, 691), - Trans(0, 55, 1, 691), - Trans(0, 61, 1, 691), - Trans(0, 62, 1, 691), - Trans(0, 66, 1, 691), - Trans(0, 67, 1, 691), - Trans(0, 81, 1, 691), - Trans(0, 93, 1, 691), - Trans(0, 94, 1, 691), - Trans(0, 95, 1, 691), - Trans(0, 96, 1, 691), - Trans(0, 97, 1, 691), - Trans(0, 100, 1, 691), - Trans(0, 102, 1, 691), - Trans(0, 104, 1, 691), - Trans(0, 105, 2, 692), - Trans(0, 106, 1, 691), - Trans(0, 107, 1, 691), - Trans(0, 110, 1, 691), - Trans(0, 111, 1, 691), + Trans(0, 52, 1, 700), + Trans(0, 54, 1, 700), + Trans(0, 55, 1, 700), + Trans(0, 56, 1, 700), + Trans(0, 62, 1, 700), + Trans(0, 63, 1, 700), + Trans(0, 67, 1, 700), + Trans(0, 68, 1, 700), + Trans(0, 82, 1, 700), + Trans(0, 94, 1, 700), + Trans(0, 95, 1, 700), + Trans(0, 96, 1, 700), + Trans(0, 97, 1, 700), + Trans(0, 98, 1, 700), + Trans(0, 101, 1, 700), + Trans(0, 103, 1, 700), + Trans(0, 105, 1, 700), + Trans(0, 106, 2, 701), + Trans(0, 107, 1, 700), + Trans(0, 108, 1, 700), + Trans(0, 111, 1, 700), + Trans(0, 112, 1, 700), ], k: 1, }, - /* 612 - "WithParameterList" */ + /* 632 - "WithParameterList" */ LookaheadDFA { - prod0: 680, + prod0: 689, transitions: &[], k: 0, }, - /* 613 - "WithParameterListList" */ + /* 633 - "WithParameterListList" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, -1), - Trans(0, 42, 7, -1), - Trans(0, 44, 8, -1), + Trans(0, 31, 1, -1), + Trans(0, 43, 7, -1), + Trans(0, 45, 8, -1), Trans(1, 5, 6, -1), - Trans(1, 35, 2, -1), - Trans(1, 38, 4, -1), - Trans(1, 42, 11, -1), - Trans(1, 44, 12, -1), - Trans(1, 80, 5, -1), - Trans(1, 89, 5, -1), - Trans(2, 5, 3, 681), - Trans(2, 39, 3, 681), - Trans(4, 5, 3, 681), - Trans(4, 35, 3, 681), - Trans(4, 38, 3, 681), - Trans(4, 80, 3, 681), - Trans(4, 89, 3, 681), - Trans(5, 5, 3, 681), - Trans(5, 111, 3, 681), - Trans(6, 35, 3, 681), - Trans(6, 38, 3, 681), - Trans(6, 42, 13, 682), - Trans(6, 44, 13, 682), - Trans(6, 80, 3, 681), - Trans(6, 89, 3, 681), + Trans(1, 36, 2, -1), + Trans(1, 39, 4, -1), + Trans(1, 43, 11, -1), + Trans(1, 45, 12, -1), + Trans(1, 81, 5, -1), + Trans(1, 90, 5, -1), + Trans(2, 5, 3, 690), + Trans(2, 40, 3, 690), + Trans(4, 5, 3, 690), + Trans(4, 36, 3, 690), + Trans(4, 39, 3, 690), + Trans(4, 81, 3, 690), + Trans(4, 90, 3, 690), + Trans(5, 5, 3, 690), + Trans(5, 112, 3, 690), + Trans(6, 36, 3, 690), + Trans(6, 39, 3, 690), + Trans(6, 43, 13, 691), + Trans(6, 45, 13, 691), + Trans(6, 81, 3, 690), + Trans(6, 90, 3, 690), Trans(7, 5, 9, -1), - Trans(7, 30, 10, -1), - Trans(7, 42, 11, -1), - Trans(7, 44, 12, -1), + Trans(7, 31, 10, -1), + Trans(7, 43, 11, -1), + Trans(7, 45, 12, -1), Trans(8, 5, 14, -1), - Trans(8, 38, 15, -1), - Trans(8, 40, 16, -1), - Trans(9, 30, 13, 682), - Trans(9, 42, 13, 682), - Trans(9, 44, 13, 682), - Trans(10, 5, 13, 682), - Trans(10, 35, 13, 682), - Trans(10, 38, 13, 682), - Trans(10, 42, 13, 682), - Trans(10, 44, 13, 682), - Trans(10, 80, 13, 682), - Trans(10, 89, 13, 682), - Trans(11, 5, 13, 682), - Trans(11, 30, 13, 682), - Trans(11, 42, 13, 682), - Trans(11, 44, 13, 682), - Trans(12, 5, 13, 682), - Trans(12, 38, 13, 682), - Trans(12, 40, 13, 682), - Trans(14, 38, 13, 682), - Trans(14, 40, 13, 682), - Trans(15, 5, 13, 682), - Trans(15, 29, 13, 682), - Trans(15, 35, 13, 682), - Trans(15, 38, 13, 682), - Trans(15, 42, 13, 682), - Trans(15, 47, 13, 682), - Trans(15, 48, 13, 682), - Trans(15, 49, 13, 682), - Trans(15, 59, 13, 682), - Trans(15, 63, 13, 682), - Trans(15, 64, 13, 682), - Trans(15, 65, 13, 682), - Trans(15, 69, 13, 682), - Trans(15, 70, 13, 682), - Trans(15, 72, 13, 682), - Trans(15, 76, 13, 682), - Trans(15, 79, 13, 682), - Trans(15, 80, 13, 682), - Trans(15, 83, 13, 682), - Trans(15, 103, 13, 682), - Trans(15, 105, 13, 682), - Trans(15, 108, 13, 682), - Trans(15, 109, 13, 682), - Trans(16, 5, 13, 682), - Trans(16, 35, 13, 682), - Trans(16, 38, 13, 682), - Trans(16, 44, 13, 682), - Trans(16, 111, 13, 682), + Trans(8, 39, 15, -1), + Trans(8, 41, 16, -1), + Trans(9, 31, 13, 691), + Trans(9, 43, 13, 691), + Trans(9, 45, 13, 691), + Trans(10, 5, 13, 691), + Trans(10, 36, 13, 691), + Trans(10, 39, 13, 691), + Trans(10, 43, 13, 691), + Trans(10, 45, 13, 691), + Trans(10, 81, 13, 691), + Trans(10, 90, 13, 691), + Trans(11, 5, 13, 691), + Trans(11, 31, 13, 691), + Trans(11, 43, 13, 691), + Trans(11, 45, 13, 691), + Trans(12, 5, 13, 691), + Trans(12, 39, 13, 691), + Trans(12, 41, 13, 691), + Trans(14, 39, 13, 691), + Trans(14, 41, 13, 691), + Trans(15, 5, 13, 691), + Trans(15, 30, 13, 691), + Trans(15, 36, 13, 691), + Trans(15, 39, 13, 691), + Trans(15, 43, 13, 691), + Trans(15, 48, 13, 691), + Trans(15, 49, 13, 691), + Trans(15, 50, 13, 691), + Trans(15, 60, 13, 691), + Trans(15, 64, 13, 691), + Trans(15, 65, 13, 691), + Trans(15, 66, 13, 691), + Trans(15, 70, 13, 691), + Trans(15, 71, 13, 691), + Trans(15, 73, 13, 691), + Trans(15, 77, 13, 691), + Trans(15, 80, 13, 691), + Trans(15, 81, 13, 691), + Trans(15, 84, 13, 691), + Trans(15, 104, 13, 691), + Trans(15, 106, 13, 691), + Trans(15, 109, 13, 691), + Trans(15, 110, 13, 691), + Trans(16, 5, 13, 691), + Trans(16, 36, 13, 691), + Trans(16, 39, 13, 691), + Trans(16, 45, 13, 691), + Trans(16, 112, 13, 691), ], k: 3, }, - /* 614 - "WithParameterListOpt" */ + /* 634 - "WithParameterListOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 30, 1, 683), - Trans(0, 42, 2, 684), - Trans(0, 44, 2, 684), + Trans(0, 31, 1, 692), + Trans(0, 43, 2, 693), + Trans(0, 45, 2, 693), ], k: 1, }, - /* 615 - "WithParameterOpt" */ + /* 635 - "WithParameterOpt" */ LookaheadDFA { prod0: -1, transitions: &[ - Trans(0, 35, 1, 678), - Trans(0, 38, 1, 678), - Trans(0, 44, 2, 679), - Trans(0, 80, 1, 678), - Trans(0, 89, 1, 678), + Trans(0, 36, 1, 687), + Trans(0, 39, 1, 687), + Trans(0, 45, 2, 688), + Trans(0, 81, 1, 687), + Trans(0, 90, 1, 687), ], k: 1, }, ]; -pub const PRODUCTIONS: &[Production; 876] = &[ +pub const PRODUCTIONS: &[Production; 908] = &[ // 0 - CommentsTerm: "(?:(?:(?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))\s*)+"; Production { - lhs: 97, + lhs: 100, production: &[ParseType::T(5)], }, // 1 - StringLiteralTerm: "\u{0022}(?:\\[\u{0022}\\/bfnrt]|u[0-9a-fA-F]{4}|[^\u{0022}\\\u0000-\u001F])*\u{0022}"; Production { - lhs: 557, + lhs: 566, production: &[ParseType::T(6)], }, // 2 - ExponentTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*[eE][+-]?[0-9]+(?:_[0-9]+)*/; Production { - lhs: 152, + lhs: 155, production: &[ParseType::T(7)], }, // 3 - FixedPointTerm: /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*/; Production { - lhs: 207, + lhs: 210, production: &[ParseType::T(8)], }, // 4 - BasedTerm: /(?:[0-9]+(?:_[0-9]+)*)?'[bodh][0-9a-fA-FxzXZ]+(?:_[0-9a-fA-FxzXZ]+)*/; @@ -14755,17 +16590,17 @@ pub const PRODUCTIONS: &[Production; 876] = &[ }, // 7 - MinusColonTerm: '-:'; Production { - lhs: 369, + lhs: 374, production: &[ParseType::T(12)], }, // 8 - MinusGTTerm: '->'; Production { - lhs: 372, + lhs: 377, production: &[ParseType::T(13)], }, // 9 - PlusColonTerm: '+:'; Production { - lhs: 467, + lhs: 474, production: &[ParseType::T(14)], }, // 10 - AssignmentOperatorTerm: "\+=|-=|\*=|/=|%=|&=|\|=|\^=|<<=|>>=|<<<=|>>>="; @@ -14775,4704 +16610,4880 @@ pub const PRODUCTIONS: &[Production; 876] = &[ }, // 11 - Operator11Term: "\*\*"; Production { - lhs: 443, + lhs: 449, production: &[ParseType::T(16)], }, // 12 - Operator10Term: "/|%"; Production { - lhs: 440, + lhs: 446, production: &[ParseType::T(17)], }, // 13 - Operator09Term: "\+|-"; Production { - lhs: 437, + lhs: 443, production: &[ParseType::T(18)], }, // 14 - Operator08Term: "<<<|>>>|<<|>>"; Production { - lhs: 434, + lhs: 440, production: &[ParseType::T(19)], }, // 15 - Operator07Term: "<=|>=|<:|>:"; Production { - lhs: 431, + lhs: 437, production: &[ParseType::T(20)], }, // 16 - Operator06Term: "===|==\?|!==|!=\?|==|!="; Production { - lhs: 428, + lhs: 434, production: &[ParseType::T(21)], }, // 17 - Operator02Term: "&&"; Production { - lhs: 416, + lhs: 422, production: &[ParseType::T(22)], }, // 18 - Operator01Term: "\|\|"; Production { - lhs: 413, + lhs: 419, production: &[ParseType::T(23)], }, // 19 - Operator05Term: "&"; Production { - lhs: 425, + lhs: 431, production: &[ParseType::T(24)], }, // 20 - Operator04Term: "\^~|\^|~\^"; Production { - lhs: 422, + lhs: 428, production: &[ParseType::T(25)], }, // 21 - Operator03Term: "\|"; Production { - lhs: 419, + lhs: 425, production: &[ParseType::T(26)], }, // 22 - UnaryOperatorTerm: "~&|~\||!|~"; Production { - lhs: 589, + lhs: 599, production: &[ParseType::T(27)], }, - // 23 - ColonColonTerm: '::'; + // 23 - ColonColonLAngleTerm: '::<'; Production { - lhs: 88, + lhs: 89, production: &[ParseType::T(28)], }, - // 24 - ColonTerm: ':'; + // 24 - ColonColonTerm: '::'; Production { - lhs: 90, + lhs: 91, production: &[ParseType::T(29)], }, - // 25 - CommaTerm: ','; + // 25 - ColonTerm: ':'; Production { lhs: 93, production: &[ParseType::T(30)], }, - // 26 - DotDotEquTerm: '..='; + // 26 - CommaTerm: ','; Production { - lhs: 118, + lhs: 96, production: &[ParseType::T(31)], }, - // 27 - DotDotTerm: '..'; + // 27 - DotDotEquTerm: '..='; Production { - lhs: 120, + lhs: 121, production: &[ParseType::T(32)], }, - // 28 - DotTerm: '.'; + // 28 - DotDotTerm: '..'; Production { - lhs: 122, + lhs: 123, production: &[ParseType::T(33)], }, - // 29 - EquTerm: '='; + // 29 - DotTerm: '.'; Production { - lhs: 149, + lhs: 125, production: &[ParseType::T(34)], }, - // 30 - HashTerm: '#'; + // 30 - EquTerm: '='; Production { - lhs: 227, + lhs: 152, production: &[ParseType::T(35)], }, - // 31 - LAngleTerm: '<'; + // 31 - HashTerm: '#'; Production { - lhs: 341, + lhs: 231, production: &[ParseType::T(36)], }, - // 32 - QuoteLBraceTerm: "'\{"; + // 32 - LAngleTerm: '<'; Production { - lhs: 484, + lhs: 346, production: &[ParseType::T(37)], }, - // 33 - LBraceTerm: '{'; + // 33 - QuoteLBraceTerm: "'\{"; Production { - lhs: 344, + lhs: 491, production: &[ParseType::T(38)], }, - // 34 - LBracketTerm: '['; + // 34 - LBraceTerm: '{'; Production { - lhs: 347, + lhs: 349, production: &[ParseType::T(39)], }, - // 35 - LParenTerm: '('; + // 35 - LBracketTerm: '['; Production { - lhs: 350, + lhs: 352, production: &[ParseType::T(40)], }, - // 36 - RAngleTerm: '>'; + // 36 - LParenTerm: '('; Production { - lhs: 487, + lhs: 355, production: &[ParseType::T(41)], }, - // 37 - RBraceTerm: '}'; + // 37 - RAngleTerm: '>'; Production { - lhs: 490, + lhs: 494, production: &[ParseType::T(42)], }, - // 38 - RBracketTerm: ']'; + // 38 - RBraceTerm: '}'; Production { - lhs: 493, + lhs: 497, production: &[ParseType::T(43)], }, - // 39 - RParenTerm: ')'; + // 39 - RBracketTerm: ']'; Production { - lhs: 496, + lhs: 500, production: &[ParseType::T(44)], }, - // 40 - SemicolonTerm: ';'; + // 40 - RParenTerm: ')'; Production { - lhs: 541, + lhs: 503, production: &[ParseType::T(45)], }, - // 41 - StarTerm: '*'; + // 41 - SemicolonTerm: ';'; Production { - lhs: 547, + lhs: 550, production: &[ParseType::T(46)], }, - // 42 - AlwaysCombTerm: /(?-u:\b)always_comb(?-u:\b)/; + // 42 - StarTerm: '*'; Production { - lhs: 6, + lhs: 556, production: &[ParseType::T(47)], }, - // 43 - AlwaysFfTerm: /(?-u:\b)always_ff(?-u:\b)/; + // 43 - AlwaysCombTerm: /(?-u:\b)always_comb(?-u:\b)/; Production { - lhs: 14, + lhs: 6, production: &[ParseType::T(48)], }, - // 44 - AssignTerm: /(?-u:\b)assign(?-u:\b)/; + // 44 - AlwaysFfTerm: /(?-u:\b)always_ff(?-u:\b)/; Production { - lhs: 36, + lhs: 14, production: &[ParseType::T(49)], }, - // 45 - AsTerm: /(?-u:\b)as(?-u:\b)/; + // 45 - AssignTerm: /(?-u:\b)assign(?-u:\b)/; Production { - lhs: 32, + lhs: 36, production: &[ParseType::T(50)], }, - // 46 - BitTerm: /(?-u:\b)bit(?-u:\b)/; + // 46 - AsTerm: /(?-u:\b)as(?-u:\b)/; Production { - lhs: 56, + lhs: 32, production: &[ParseType::T(51)], }, - // 47 - CaseTerm: /(?-u:\b)case(?-u:\b)/; + // 47 - BitTerm: /(?-u:\b)bit(?-u:\b)/; Production { - lhs: 75, + lhs: 56, production: &[ParseType::T(52)], }, - // 48 - ClockTerm: /(?-u:\b)clock(?-u:\b)/; + // 48 - CaseTerm: /(?-u:\b)case(?-u:\b)/; Production { - lhs: 84, + lhs: 75, production: &[ParseType::T(53)], }, - // 49 - ClockPosedgeTerm: /(?-u:\b)clock_posedge(?-u:\b)/; + // 49 - ClockTerm: /(?-u:\b)clock(?-u:\b)/; Production { - lhs: 82, + lhs: 84, production: &[ParseType::T(54)], }, - // 50 - ClockNegedgeTerm: /(?-u:\b)clock_negedge(?-u:\b)/; + // 50 - ClockPosedgeTerm: /(?-u:\b)clock_posedge(?-u:\b)/; Production { - lhs: 79, + lhs: 82, production: &[ParseType::T(55)], }, - // 51 - DefaultTerm: /(?-u:\b)default(?-u:\b)/; + // 51 - ClockNegedgeTerm: /(?-u:\b)clock_negedge(?-u:\b)/; Production { - lhs: 104, + lhs: 79, production: &[ParseType::T(56)], }, - // 52 - ElseTerm: /(?-u:\b)else(?-u:\b)/; + // 52 - DefaultTerm: /(?-u:\b)default(?-u:\b)/; Production { - lhs: 125, + lhs: 107, production: &[ParseType::T(57)], }, - // 53 - EmbedTerm: /(?-u:\b)embed(?-u:\b)/; + // 53 - ElseTerm: /(?-u:\b)else(?-u:\b)/; Production { - lhs: 134, + lhs: 128, production: &[ParseType::T(58)], }, - // 54 - EnumTerm: /(?-u:\b)enum(?-u:\b)/; + // 54 - EmbedTerm: /(?-u:\b)embed(?-u:\b)/; Production { - lhs: 146, + lhs: 137, production: &[ParseType::T(59)], }, - // 55 - ExportTerm: /(?-u:\b)export(?-u:\b)/; + // 55 - EnumTerm: /(?-u:\b)enum(?-u:\b)/; Production { - lhs: 158, + lhs: 149, production: &[ParseType::T(60)], }, - // 56 - F32Term: /(?-u:\b)f32(?-u:\b)/; + // 56 - ExportTerm: /(?-u:\b)export(?-u:\b)/; Production { - lhs: 193, + lhs: 161, production: &[ParseType::T(61)], }, - // 57 - F64Term: /(?-u:\b)f64(?-u:\b)/; + // 57 - F32Term: /(?-u:\b)f32(?-u:\b)/; Production { lhs: 196, production: &[ParseType::T(62)], }, - // 58 - FinalTerm: /(?-u:\b)final(?-u:\b)/; + // 58 - F64Term: /(?-u:\b)f64(?-u:\b)/; Production { - lhs: 204, + lhs: 199, production: &[ParseType::T(63)], }, - // 59 - ForTerm: /(?-u:\b)for(?-u:\b)/; + // 59 - FinalTerm: /(?-u:\b)final(?-u:\b)/; Production { - lhs: 214, + lhs: 207, production: &[ParseType::T(64)], }, - // 60 - FunctionTerm: /(?-u:\b)function(?-u:\b)/; + // 60 - ForTerm: /(?-u:\b)for(?-u:\b)/; Production { - lhs: 224, + lhs: 217, production: &[ParseType::T(65)], }, - // 61 - I32Term: /(?-u:\b)i32(?-u:\b)/; + // 61 - FunctionTerm: /(?-u:\b)function(?-u:\b)/; Production { - lhs: 234, + lhs: 228, production: &[ParseType::T(66)], }, - // 62 - I64Term: /(?-u:\b)i64(?-u:\b)/; + // 62 - I32Term: /(?-u:\b)i32(?-u:\b)/; Production { - lhs: 237, + lhs: 238, production: &[ParseType::T(67)], }, - // 63 - IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/; + // 63 - I64Term: /(?-u:\b)i64(?-u:\b)/; Production { - lhs: 254, + lhs: 241, production: &[ParseType::T(68)], }, - // 64 - IfTerm: /(?-u:\b)if(?-u:\b)/; + // 64 - IfResetTerm: /(?-u:\b)if_reset(?-u:\b)/; Production { - lhs: 262, + lhs: 258, production: &[ParseType::T(69)], }, - // 65 - ImportTerm: /(?-u:\b)import(?-u:\b)/; + // 65 - IfTerm: /(?-u:\b)if(?-u:\b)/; Production { - lhs: 267, + lhs: 266, production: &[ParseType::T(70)], }, - // 66 - IncludeTerm: /(?-u:\b)include(?-u:\b)/; + // 66 - ImportTerm: /(?-u:\b)import(?-u:\b)/; Production { - lhs: 274, + lhs: 271, production: &[ParseType::T(71)], }, - // 67 - InitialTerm: /(?-u:\b)initial(?-u:\b)/; + // 67 - IncludeTerm: /(?-u:\b)include(?-u:\b)/; Production { - lhs: 279, + lhs: 278, production: &[ParseType::T(72)], }, - // 68 - InoutTerm: /(?-u:\b)inout(?-u:\b)/; + // 68 - InitialTerm: /(?-u:\b)initial(?-u:\b)/; Production { - lhs: 282, + lhs: 283, production: &[ParseType::T(73)], }, - // 69 - InputTerm: /(?-u:\b)input(?-u:\b)/; + // 69 - InoutTerm: /(?-u:\b)inout(?-u:\b)/; Production { - lhs: 285, + lhs: 286, production: &[ParseType::T(74)], }, - // 70 - InsideTerm: /(?-u:\b)inside(?-u:\b)/; + // 70 - InputTerm: /(?-u:\b)input(?-u:\b)/; Production { lhs: 289, production: &[ParseType::T(75)], }, - // 71 - InstTerm: /(?-u:\b)inst(?-u:\b)/; + // 71 - InsideTerm: /(?-u:\b)inside(?-u:\b)/; Production { - lhs: 315, + lhs: 293, production: &[ParseType::T(76)], }, - // 72 - InterfaceTerm: /(?-u:\b)interface(?-u:\b)/; + // 72 - InstTerm: /(?-u:\b)inst(?-u:\b)/; Production { - lhs: 338, + lhs: 319, production: &[ParseType::T(77)], }, - // 73 - InTerm: /(?-u:\b)in(?-u:\b)/; + // 73 - InterfaceTerm: /(?-u:\b)interface(?-u:\b)/; Production { - lhs: 270, + lhs: 343, production: &[ParseType::T(78)], }, - // 74 - LetTerm: /(?-u:\b)let(?-u:\b)/; + // 74 - InTerm: /(?-u:\b)in(?-u:\b)/; Production { - lhs: 355, + lhs: 274, production: &[ParseType::T(79)], }, - // 75 - LocalTerm: /(?-u:\b)local(?-u:\b)/; + // 75 - LetTerm: /(?-u:\b)let(?-u:\b)/; Production { lhs: 360, production: &[ParseType::T(80)], }, - // 76 - LogicTerm: /(?-u:\b)logic(?-u:\b)/; + // 76 - LocalTerm: /(?-u:\b)local(?-u:\b)/; Production { - lhs: 363, + lhs: 365, production: &[ParseType::T(81)], }, - // 77 - LsbTerm: /(?-u:\b)lsb(?-u:\b)/; + // 77 - LogicTerm: /(?-u:\b)logic(?-u:\b)/; Production { - lhs: 366, + lhs: 368, production: &[ParseType::T(82)], }, - // 78 - ModportTerm: /(?-u:\b)modport(?-u:\b)/; + // 78 - LsbTerm: /(?-u:\b)lsb(?-u:\b)/; Production { - lhs: 383, + lhs: 371, production: &[ParseType::T(83)], }, - // 79 - ModuleTerm: /(?-u:\b)module(?-u:\b)/; + // 79 - ModportTerm: /(?-u:\b)modport(?-u:\b)/; Production { - lhs: 406, + lhs: 388, production: &[ParseType::T(84)], }, - // 80 - MsbTerm: /(?-u:\b)msb(?-u:\b)/; + // 80 - ModuleTerm: /(?-u:\b)module(?-u:\b)/; Production { - lhs: 409, + lhs: 412, production: &[ParseType::T(85)], }, - // 81 - OutputTerm: /(?-u:\b)output(?-u:\b)/; + // 81 - MsbTerm: /(?-u:\b)msb(?-u:\b)/; Production { - lhs: 446, + lhs: 415, production: &[ParseType::T(86)], }, - // 82 - OutsideTerm: /(?-u:\b)outside(?-u:\b)/; + // 82 - OutputTerm: /(?-u:\b)output(?-u:\b)/; Production { - lhs: 450, + lhs: 452, production: &[ParseType::T(87)], }, - // 83 - PackageTerm: /(?-u:\b)package(?-u:\b)/; + // 83 - OutsideTerm: /(?-u:\b)outside(?-u:\b)/; Production { - lhs: 461, + lhs: 456, production: &[ParseType::T(88)], }, - // 84 - ParamTerm: /(?-u:\b)param(?-u:\b)/; + // 84 - PackageTerm: /(?-u:\b)package(?-u:\b)/; Production { - lhs: 464, + lhs: 468, production: &[ParseType::T(89)], }, - // 85 - PubTerm: /(?-u:\b)pub(?-u:\b)/; + // 85 - ParamTerm: /(?-u:\b)param(?-u:\b)/; Production { - lhs: 481, + lhs: 471, production: &[ParseType::T(90)], }, - // 86 - RefTerm: /(?-u:\b)ref(?-u:\b)/; + // 86 - PubTerm: /(?-u:\b)pub(?-u:\b)/; Production { - lhs: 507, + lhs: 488, production: &[ParseType::T(91)], }, - // 87 - RepeatTerm: /(?-u:\b)repeat(?-u:\b)/; + // 87 - RefTerm: /(?-u:\b)ref(?-u:\b)/; Production { - lhs: 510, + lhs: 514, production: &[ParseType::T(92)], }, - // 88 - ResetTerm: /(?-u:\b)reset(?-u:\b)/; + // 88 - RepeatTerm: /(?-u:\b)repeat(?-u:\b)/; Production { - lhs: 525, + lhs: 517, production: &[ParseType::T(93)], }, - // 89 - ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/; + // 89 - ResetTerm: /(?-u:\b)reset(?-u:\b)/; Production { - lhs: 514, + lhs: 532, production: &[ParseType::T(94)], }, - // 90 - ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/; + // 90 - ResetAsyncHighTerm: /(?-u:\b)reset_async_high(?-u:\b)/; Production { - lhs: 517, + lhs: 521, production: &[ParseType::T(95)], }, - // 91 - ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/; + // 91 - ResetAsyncLowTerm: /(?-u:\b)reset_async_low(?-u:\b)/; Production { - lhs: 520, + lhs: 524, production: &[ParseType::T(96)], }, - // 92 - ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/; + // 92 - ResetSyncHighTerm: /(?-u:\b)reset_sync_high(?-u:\b)/; Production { - lhs: 523, + lhs: 527, production: &[ParseType::T(97)], }, - // 93 - ReturnTerm: /(?-u:\b)return(?-u:\b)/; + // 93 - ResetSyncLowTerm: /(?-u:\b)reset_sync_low(?-u:\b)/; Production { - lhs: 529, + lhs: 530, production: &[ParseType::T(98)], }, - // 94 - BreakTerm: /(?-u:\b)break(?-u:\b)/; + // 94 - ReturnTerm: /(?-u:\b)return(?-u:\b)/; Production { - lhs: 60, + lhs: 536, production: &[ParseType::T(99)], }, - // 95 - SignedTerm: /(?-u:\b)signed(?-u:\b)/; + // 95 - BreakTerm: /(?-u:\b)break(?-u:\b)/; Production { - lhs: 544, + lhs: 60, production: &[ParseType::T(100)], }, - // 96 - StepTerm: /(?-u:\b)step(?-u:\b)/; + // 96 - SignedTerm: /(?-u:\b)signed(?-u:\b)/; Production { lhs: 553, production: &[ParseType::T(101)], }, - // 97 - StringTerm: /(?-u:\b)string(?-u:\b)/; + // 97 - StepTerm: /(?-u:\b)step(?-u:\b)/; Production { - lhs: 559, + lhs: 562, production: &[ParseType::T(102)], }, - // 98 - StructTerm: /(?-u:\b)struct(?-u:\b)/; + // 98 - StringTerm: /(?-u:\b)string(?-u:\b)/; Production { - lhs: 562, + lhs: 568, production: &[ParseType::T(103)], }, - // 99 - TriTerm: /(?-u:\b)tri(?-u:\b)/; + // 99 - StructTerm: /(?-u:\b)struct(?-u:\b)/; Production { - lhs: 574, + lhs: 571, production: &[ParseType::T(104)], }, - // 100 - TypeTerm: /(?-u:\b)type(?-u:\b)/; + // 100 - TriTerm: /(?-u:\b)tri(?-u:\b)/; Production { - lhs: 580, + lhs: 584, production: &[ParseType::T(105)], }, - // 101 - U32Term: /(?-u:\b)u32(?-u:\b)/; + // 101 - TypeTerm: /(?-u:\b)type(?-u:\b)/; Production { - lhs: 583, + lhs: 590, production: &[ParseType::T(106)], }, - // 102 - U64Term: /(?-u:\b)u64(?-u:\b)/; + // 102 - U32Term: /(?-u:\b)u32(?-u:\b)/; Production { - lhs: 586, + lhs: 593, production: &[ParseType::T(107)], }, - // 103 - UnionTerm: /(?-u:\b)union(?-u:\b)/; + // 103 - U64Term: /(?-u:\b)u64(?-u:\b)/; Production { - lhs: 592, + lhs: 596, production: &[ParseType::T(108)], }, - // 104 - VarTerm: /(?-u:\b)var(?-u:\b)/; + // 104 - UnionTerm: /(?-u:\b)union(?-u:\b)/; Production { - lhs: 596, + lhs: 602, production: &[ParseType::T(109)], }, - // 105 - DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/; + // 105 - VarTerm: /(?-u:\b)var(?-u:\b)/; Production { - lhs: 113, + lhs: 606, production: &[ParseType::T(110)], }, - // 106 - IdentifierTerm: /[a-zA-Z_][0-9a-zA-Z_$]*/; + // 106 - DollarIdentifierTerm: /\$[a-zA-Z_][0-9a-zA-Z_$]*/; Production { - lhs: 242, + lhs: 116, production: &[ParseType::T(111)], }, - // 107 - AnyTerm: /[^{}]*/; + // 107 - IdentifierTerm: /[a-zA-Z_][0-9a-zA-Z_$]*/; Production { - lhs: 16, + lhs: 246, production: &[ParseType::T(112)], }, - // 108 - Comments: CommentsOpt /* Option */; + // 108 - AnyTerm: /[^{}]*/; Production { - lhs: 95, - production: &[ParseType::N(96)], + lhs: 16, + production: &[ParseType::T(113)], }, - // 109 - CommentsOpt: CommentsTerm; + // 109 - Comments: CommentsOpt /* Option */; Production { - lhs: 96, - production: &[ParseType::N(97)], + lhs: 98, + production: &[ParseType::N(99)], }, - // 110 - CommentsOpt: ; + // 110 - CommentsOpt: CommentsTerm; Production { - lhs: 96, + lhs: 99, + production: &[ParseType::N(100)], + }, + // 111 - CommentsOpt: ; + Production { + lhs: 99, production: &[], }, - // 111 - StartToken: Comments; + // 112 - StartToken: Comments; Production { - lhs: 550, - production: &[ParseType::N(95)], + lhs: 559, + production: &[ParseType::N(98)], }, - // 112 - StringLiteralToken: StringLiteralTerm : crate::veryl_token::Token Comments; + // 113 - StringLiteralToken: StringLiteralTerm : crate::veryl_token::Token Comments; Production { - lhs: 558, - production: &[ParseType::N(95), ParseType::N(557)], + lhs: 567, + production: &[ParseType::N(98), ParseType::N(566)], }, - // 113 - ExponentToken: ExponentTerm : crate::veryl_token::Token Comments; + // 114 - ExponentToken: ExponentTerm : crate::veryl_token::Token Comments; Production { - lhs: 153, - production: &[ParseType::N(95), ParseType::N(152)], + lhs: 156, + production: &[ParseType::N(98), ParseType::N(155)], }, - // 114 - FixedPointToken: FixedPointTerm : crate::veryl_token::Token Comments; + // 115 - FixedPointToken: FixedPointTerm : crate::veryl_token::Token Comments; Production { - lhs: 208, - production: &[ParseType::N(95), ParseType::N(207)], + lhs: 211, + production: &[ParseType::N(98), ParseType::N(210)], }, - // 115 - BasedToken: BasedTerm : crate::veryl_token::Token Comments; + // 116 - BasedToken: BasedTerm : crate::veryl_token::Token Comments; Production { lhs: 54, - production: &[ParseType::N(95), ParseType::N(53)], + production: &[ParseType::N(98), ParseType::N(53)], }, - // 116 - BaseLessToken: BaseLessTerm : crate::veryl_token::Token Comments; + // 117 - BaseLessToken: BaseLessTerm : crate::veryl_token::Token Comments; Production { lhs: 51, - production: &[ParseType::N(95), ParseType::N(50)], + production: &[ParseType::N(98), ParseType::N(50)], }, - // 117 - AllBitToken: AllBitTerm : crate::veryl_token::Token Comments; + // 118 - AllBitToken: AllBitTerm : crate::veryl_token::Token Comments; Production { lhs: 2, - production: &[ParseType::N(95), ParseType::N(1)], + production: &[ParseType::N(98), ParseType::N(1)], }, - // 118 - AssignmentOperatorToken: AssignmentOperatorTerm : crate::veryl_token::Token Comments; + // 119 - AssignmentOperatorToken: AssignmentOperatorTerm : crate::veryl_token::Token Comments; Production { lhs: 42, - production: &[ParseType::N(95), ParseType::N(41)], - }, - // 119 - Operator01Token: Operator01Term : crate::veryl_token::Token Comments; - Production { - lhs: 414, - production: &[ParseType::N(95), ParseType::N(413)], + production: &[ParseType::N(98), ParseType::N(41)], }, - // 120 - Operator02Token: Operator02Term : crate::veryl_token::Token Comments; - Production { - lhs: 417, - production: &[ParseType::N(95), ParseType::N(416)], - }, - // 121 - Operator03Token: Operator03Term : crate::veryl_token::Token Comments; + // 120 - Operator01Token: Operator01Term : crate::veryl_token::Token Comments; Production { lhs: 420, - production: &[ParseType::N(95), ParseType::N(419)], + production: &[ParseType::N(98), ParseType::N(419)], }, - // 122 - Operator04Token: Operator04Term : crate::veryl_token::Token Comments; + // 121 - Operator02Token: Operator02Term : crate::veryl_token::Token Comments; Production { lhs: 423, - production: &[ParseType::N(95), ParseType::N(422)], + production: &[ParseType::N(98), ParseType::N(422)], }, - // 123 - Operator05Token: Operator05Term : crate::veryl_token::Token Comments; + // 122 - Operator03Token: Operator03Term : crate::veryl_token::Token Comments; Production { lhs: 426, - production: &[ParseType::N(95), ParseType::N(425)], + production: &[ParseType::N(98), ParseType::N(425)], }, - // 124 - Operator06Token: Operator06Term : crate::veryl_token::Token Comments; + // 123 - Operator04Token: Operator04Term : crate::veryl_token::Token Comments; Production { lhs: 429, - production: &[ParseType::N(95), ParseType::N(428)], + production: &[ParseType::N(98), ParseType::N(428)], }, - // 125 - Operator07Token: Operator07Term : crate::veryl_token::Token Comments; + // 124 - Operator05Token: Operator05Term : crate::veryl_token::Token Comments; Production { lhs: 432, - production: &[ParseType::N(95), ParseType::N(431)], + production: &[ParseType::N(98), ParseType::N(431)], }, - // 126 - Operator08Token: Operator08Term : crate::veryl_token::Token Comments; + // 125 - Operator06Token: Operator06Term : crate::veryl_token::Token Comments; Production { lhs: 435, - production: &[ParseType::N(95), ParseType::N(434)], + production: &[ParseType::N(98), ParseType::N(434)], }, - // 127 - Operator09Token: Operator09Term : crate::veryl_token::Token Comments; + // 126 - Operator07Token: Operator07Term : crate::veryl_token::Token Comments; Production { lhs: 438, - production: &[ParseType::N(95), ParseType::N(437)], + production: &[ParseType::N(98), ParseType::N(437)], }, - // 128 - Operator10Token: Operator10Term : crate::veryl_token::Token Comments; + // 127 - Operator08Token: Operator08Term : crate::veryl_token::Token Comments; Production { lhs: 441, - production: &[ParseType::N(95), ParseType::N(440)], + production: &[ParseType::N(98), ParseType::N(440)], }, - // 129 - Operator11Token: Operator11Term : crate::veryl_token::Token Comments; + // 128 - Operator09Token: Operator09Term : crate::veryl_token::Token Comments; Production { lhs: 444, - production: &[ParseType::N(95), ParseType::N(443)], + production: &[ParseType::N(98), ParseType::N(443)], }, - // 130 - UnaryOperatorToken: UnaryOperatorTerm : crate::veryl_token::Token Comments; + // 129 - Operator10Token: Operator10Term : crate::veryl_token::Token Comments; Production { - lhs: 590, - production: &[ParseType::N(95), ParseType::N(589)], + lhs: 447, + production: &[ParseType::N(98), ParseType::N(446)], }, - // 131 - ColonToken: ColonTerm : crate::veryl_token::Token Comments; + // 130 - Operator11Token: Operator11Term : crate::veryl_token::Token Comments; Production { - lhs: 91, - production: &[ParseType::N(95), ParseType::N(90)], + lhs: 450, + production: &[ParseType::N(98), ParseType::N(449)], }, - // 132 - ColonColonToken: ColonColonTerm : crate::veryl_token::Token Comments; + // 131 - UnaryOperatorToken: UnaryOperatorTerm : crate::veryl_token::Token Comments; Production { - lhs: 89, - production: &[ParseType::N(95), ParseType::N(88)], + lhs: 600, + production: &[ParseType::N(98), ParseType::N(599)], }, - // 133 - CommaToken: CommaTerm : crate::veryl_token::Token Comments; + // 132 - ColonToken: ColonTerm : crate::veryl_token::Token Comments; Production { lhs: 94, - production: &[ParseType::N(95), ParseType::N(93)], + production: &[ParseType::N(98), ParseType::N(93)], }, - // 134 - DotDotToken: DotDotTerm : crate::veryl_token::Token Comments; + // 133 - ColonColonLAngleToken: ColonColonLAngleTerm : crate::veryl_token::Token Comments; Production { - lhs: 121, - production: &[ParseType::N(95), ParseType::N(120)], + lhs: 90, + production: &[ParseType::N(98), ParseType::N(89)], }, - // 135 - DotDotEquToken: DotDotEquTerm : crate::veryl_token::Token Comments; + // 134 - ColonColonToken: ColonColonTerm : crate::veryl_token::Token Comments; Production { - lhs: 119, - production: &[ParseType::N(95), ParseType::N(118)], + lhs: 92, + production: &[ParseType::N(98), ParseType::N(91)], }, - // 136 - DotToken: DotTerm : crate::veryl_token::Token Comments; + // 135 - CommaToken: CommaTerm : crate::veryl_token::Token Comments; Production { - lhs: 123, - production: &[ParseType::N(95), ParseType::N(122)], + lhs: 97, + production: &[ParseType::N(98), ParseType::N(96)], }, - // 137 - EquToken: EquTerm : crate::veryl_token::Token Comments; + // 136 - DotDotToken: DotDotTerm : crate::veryl_token::Token Comments; Production { - lhs: 150, - production: &[ParseType::N(95), ParseType::N(149)], + lhs: 124, + production: &[ParseType::N(98), ParseType::N(123)], }, - // 138 - HashToken: HashTerm : crate::veryl_token::Token Comments; + // 137 - DotDotEquToken: DotDotEquTerm : crate::veryl_token::Token Comments; Production { - lhs: 228, - production: &[ParseType::N(95), ParseType::N(227)], + lhs: 122, + production: &[ParseType::N(98), ParseType::N(121)], }, - // 139 - QuoteLBraceToken: QuoteLBraceTerm : crate::veryl_token::Token Comments; + // 138 - DotToken: DotTerm : crate::veryl_token::Token Comments; Production { - lhs: 485, - production: &[ParseType::N(95), ParseType::N(484)], + lhs: 126, + production: &[ParseType::N(98), ParseType::N(125)], }, - // 140 - LAngleToken: LAngleTerm : crate::veryl_token::Token Comments; + // 139 - EquToken: EquTerm : crate::veryl_token::Token Comments; Production { - lhs: 342, - production: &[ParseType::N(95), ParseType::N(341)], + lhs: 153, + production: &[ParseType::N(98), ParseType::N(152)], }, - // 141 - LBraceToken: LBraceTerm : crate::veryl_token::Token Comments; + // 140 - HashToken: HashTerm : crate::veryl_token::Token Comments; Production { - lhs: 345, - production: &[ParseType::N(95), ParseType::N(344)], + lhs: 232, + production: &[ParseType::N(98), ParseType::N(231)], }, - // 142 - LBracketToken: LBracketTerm : crate::veryl_token::Token Comments; + // 141 - QuoteLBraceToken: QuoteLBraceTerm : crate::veryl_token::Token Comments; Production { - lhs: 348, - production: &[ParseType::N(95), ParseType::N(347)], + lhs: 492, + production: &[ParseType::N(98), ParseType::N(491)], }, - // 143 - LParenToken: LParenTerm : crate::veryl_token::Token Comments; + // 142 - LAngleToken: LAngleTerm : crate::veryl_token::Token Comments; Production { - lhs: 351, - production: &[ParseType::N(95), ParseType::N(350)], + lhs: 347, + production: &[ParseType::N(98), ParseType::N(346)], }, - // 144 - MinusColonToken: MinusColonTerm : crate::veryl_token::Token Comments; + // 143 - LBraceToken: LBraceTerm : crate::veryl_token::Token Comments; Production { - lhs: 370, - production: &[ParseType::N(95), ParseType::N(369)], + lhs: 350, + production: &[ParseType::N(98), ParseType::N(349)], }, - // 145 - MinusGTToken: MinusGTTerm : crate::veryl_token::Token Comments; + // 144 - LBracketToken: LBracketTerm : crate::veryl_token::Token Comments; Production { - lhs: 373, - production: &[ParseType::N(95), ParseType::N(372)], + lhs: 353, + production: &[ParseType::N(98), ParseType::N(352)], }, - // 146 - PlusColonToken: PlusColonTerm : crate::veryl_token::Token Comments; + // 145 - LParenToken: LParenTerm : crate::veryl_token::Token Comments; Production { - lhs: 468, - production: &[ParseType::N(95), ParseType::N(467)], + lhs: 356, + production: &[ParseType::N(98), ParseType::N(355)], }, - // 147 - RAngleToken: RAngleTerm : crate::veryl_token::Token Comments; + // 146 - MinusColonToken: MinusColonTerm : crate::veryl_token::Token Comments; Production { - lhs: 488, - production: &[ParseType::N(95), ParseType::N(487)], + lhs: 375, + production: &[ParseType::N(98), ParseType::N(374)], }, - // 148 - RBraceToken: RBraceTerm : crate::veryl_token::Token Comments; + // 147 - MinusGTToken: MinusGTTerm : crate::veryl_token::Token Comments; Production { - lhs: 491, - production: &[ParseType::N(95), ParseType::N(490)], + lhs: 378, + production: &[ParseType::N(98), ParseType::N(377)], }, - // 149 - RBracketToken: RBracketTerm : crate::veryl_token::Token Comments; + // 148 - PlusColonToken: PlusColonTerm : crate::veryl_token::Token Comments; Production { - lhs: 494, - production: &[ParseType::N(95), ParseType::N(493)], + lhs: 475, + production: &[ParseType::N(98), ParseType::N(474)], }, - // 150 - RParenToken: RParenTerm : crate::veryl_token::Token Comments; + // 149 - RAngleToken: RAngleTerm : crate::veryl_token::Token Comments; Production { - lhs: 497, - production: &[ParseType::N(95), ParseType::N(496)], + lhs: 495, + production: &[ParseType::N(98), ParseType::N(494)], }, - // 151 - SemicolonToken: SemicolonTerm : crate::veryl_token::Token Comments; + // 150 - RBraceToken: RBraceTerm : crate::veryl_token::Token Comments; Production { - lhs: 542, - production: &[ParseType::N(95), ParseType::N(541)], + lhs: 498, + production: &[ParseType::N(98), ParseType::N(497)], }, - // 152 - StarToken: StarTerm : crate::veryl_token::Token Comments; + // 151 - RBracketToken: RBracketTerm : crate::veryl_token::Token Comments; Production { - lhs: 548, - production: &[ParseType::N(95), ParseType::N(547)], + lhs: 501, + production: &[ParseType::N(98), ParseType::N(500)], + }, + // 152 - RParenToken: RParenTerm : crate::veryl_token::Token Comments; + Production { + lhs: 504, + production: &[ParseType::N(98), ParseType::N(503)], + }, + // 153 - SemicolonToken: SemicolonTerm : crate::veryl_token::Token Comments; + Production { + lhs: 551, + production: &[ParseType::N(98), ParseType::N(550)], + }, + // 154 - StarToken: StarTerm : crate::veryl_token::Token Comments; + Production { + lhs: 557, + production: &[ParseType::N(98), ParseType::N(556)], }, - // 153 - AlwaysCombToken: AlwaysCombTerm : crate::veryl_token::Token Comments; + // 155 - AlwaysCombToken: AlwaysCombTerm : crate::veryl_token::Token Comments; Production { lhs: 7, - production: &[ParseType::N(95), ParseType::N(6)], + production: &[ParseType::N(98), ParseType::N(6)], }, - // 154 - AlwaysFfToken: AlwaysFfTerm : crate::veryl_token::Token Comments; + // 156 - AlwaysFfToken: AlwaysFfTerm : crate::veryl_token::Token Comments; Production { lhs: 15, - production: &[ParseType::N(95), ParseType::N(14)], + production: &[ParseType::N(98), ParseType::N(14)], }, - // 155 - AsToken: AsTerm : crate::veryl_token::Token Comments; + // 157 - AsToken: AsTerm : crate::veryl_token::Token Comments; Production { lhs: 33, - production: &[ParseType::N(95), ParseType::N(32)], + production: &[ParseType::N(98), ParseType::N(32)], }, - // 156 - AssignToken: AssignTerm : crate::veryl_token::Token Comments; + // 158 - AssignToken: AssignTerm : crate::veryl_token::Token Comments; Production { lhs: 37, - production: &[ParseType::N(95), ParseType::N(36)], + production: &[ParseType::N(98), ParseType::N(36)], }, - // 157 - BitToken: BitTerm : crate::veryl_token::Token Comments; + // 159 - BitToken: BitTerm : crate::veryl_token::Token Comments; Production { lhs: 57, - production: &[ParseType::N(95), ParseType::N(56)], + production: &[ParseType::N(98), ParseType::N(56)], }, - // 158 - CaseToken: CaseTerm : crate::veryl_token::Token Comments; + // 160 - CaseToken: CaseTerm : crate::veryl_token::Token Comments; Production { lhs: 76, - production: &[ParseType::N(95), ParseType::N(75)], + production: &[ParseType::N(98), ParseType::N(75)], }, - // 159 - ClockToken: ClockTerm : crate::veryl_token::Token Comments; + // 161 - ClockToken: ClockTerm : crate::veryl_token::Token Comments; Production { lhs: 85, - production: &[ParseType::N(95), ParseType::N(84)], + production: &[ParseType::N(98), ParseType::N(84)], }, - // 160 - ClockPosedgeToken: ClockPosedgeTerm : crate::veryl_token::Token Comments; + // 162 - ClockPosedgeToken: ClockPosedgeTerm : crate::veryl_token::Token Comments; Production { lhs: 83, - production: &[ParseType::N(95), ParseType::N(82)], + production: &[ParseType::N(98), ParseType::N(82)], }, - // 161 - ClockNegedgeToken: ClockNegedgeTerm : crate::veryl_token::Token Comments; + // 163 - ClockNegedgeToken: ClockNegedgeTerm : crate::veryl_token::Token Comments; Production { lhs: 80, - production: &[ParseType::N(95), ParseType::N(79)], + production: &[ParseType::N(98), ParseType::N(79)], }, - // 162 - DefaultToken: DefaultTerm : crate::veryl_token::Token Comments; + // 164 - DefaultToken: DefaultTerm : crate::veryl_token::Token Comments; Production { - lhs: 105, - production: &[ParseType::N(95), ParseType::N(104)], - }, - // 163 - ElseToken: ElseTerm : crate::veryl_token::Token Comments; - Production { - lhs: 126, - production: &[ParseType::N(95), ParseType::N(125)], + lhs: 108, + production: &[ParseType::N(98), ParseType::N(107)], }, - // 164 - EmbedToken: EmbedTerm : crate::veryl_token::Token Comments; + // 165 - ElseToken: ElseTerm : crate::veryl_token::Token Comments; Production { - lhs: 135, - production: &[ParseType::N(95), ParseType::N(134)], + lhs: 129, + production: &[ParseType::N(98), ParseType::N(128)], }, - // 165 - EnumToken: EnumTerm : crate::veryl_token::Token Comments; + // 166 - EmbedToken: EmbedTerm : crate::veryl_token::Token Comments; Production { - lhs: 147, - production: &[ParseType::N(95), ParseType::N(146)], + lhs: 138, + production: &[ParseType::N(98), ParseType::N(137)], }, - // 166 - ExportToken: ExportTerm : crate::veryl_token::Token Comments; + // 167 - EnumToken: EnumTerm : crate::veryl_token::Token Comments; Production { - lhs: 159, - production: &[ParseType::N(95), ParseType::N(158)], + lhs: 150, + production: &[ParseType::N(98), ParseType::N(149)], }, - // 167 - F32Token: F32Term : crate::veryl_token::Token Comments; + // 168 - ExportToken: ExportTerm : crate::veryl_token::Token Comments; Production { - lhs: 194, - production: &[ParseType::N(95), ParseType::N(193)], + lhs: 162, + production: &[ParseType::N(98), ParseType::N(161)], }, - // 168 - F64Token: F64Term : crate::veryl_token::Token Comments; + // 169 - F32Token: F32Term : crate::veryl_token::Token Comments; Production { lhs: 197, - production: &[ParseType::N(95), ParseType::N(196)], + production: &[ParseType::N(98), ParseType::N(196)], }, - // 169 - FinalToken: FinalTerm : crate::veryl_token::Token Comments; + // 170 - F64Token: F64Term : crate::veryl_token::Token Comments; Production { - lhs: 205, - production: &[ParseType::N(95), ParseType::N(204)], + lhs: 200, + production: &[ParseType::N(98), ParseType::N(199)], }, - // 170 - ForToken: ForTerm : crate::veryl_token::Token Comments; + // 171 - FinalToken: FinalTerm : crate::veryl_token::Token Comments; Production { - lhs: 215, - production: &[ParseType::N(95), ParseType::N(214)], + lhs: 208, + production: &[ParseType::N(98), ParseType::N(207)], }, - // 171 - FunctionToken: FunctionTerm : crate::veryl_token::Token Comments; + // 172 - ForToken: ForTerm : crate::veryl_token::Token Comments; Production { - lhs: 225, - production: &[ParseType::N(95), ParseType::N(224)], + lhs: 218, + production: &[ParseType::N(98), ParseType::N(217)], }, - // 172 - I32Token: I32Term : crate::veryl_token::Token Comments; + // 173 - FunctionToken: FunctionTerm : crate::veryl_token::Token Comments; Production { - lhs: 235, - production: &[ParseType::N(95), ParseType::N(234)], + lhs: 229, + production: &[ParseType::N(98), ParseType::N(228)], }, - // 173 - I64Token: I64Term : crate::veryl_token::Token Comments; + // 174 - I32Token: I32Term : crate::veryl_token::Token Comments; Production { - lhs: 238, - production: &[ParseType::N(95), ParseType::N(237)], + lhs: 239, + production: &[ParseType::N(98), ParseType::N(238)], }, - // 174 - IfResetToken: IfResetTerm : crate::veryl_token::Token Comments; + // 175 - I64Token: I64Term : crate::veryl_token::Token Comments; Production { - lhs: 255, - production: &[ParseType::N(95), ParseType::N(254)], + lhs: 242, + production: &[ParseType::N(98), ParseType::N(241)], }, - // 175 - IfToken: IfTerm : crate::veryl_token::Token Comments; + // 176 - IfResetToken: IfResetTerm : crate::veryl_token::Token Comments; Production { - lhs: 263, - production: &[ParseType::N(95), ParseType::N(262)], + lhs: 259, + production: &[ParseType::N(98), ParseType::N(258)], }, - // 176 - ImportToken: ImportTerm : crate::veryl_token::Token Comments; + // 177 - IfToken: IfTerm : crate::veryl_token::Token Comments; Production { - lhs: 268, - production: &[ParseType::N(95), ParseType::N(267)], + lhs: 267, + production: &[ParseType::N(98), ParseType::N(266)], }, - // 177 - IncludeToken: IncludeTerm : crate::veryl_token::Token Comments; + // 178 - ImportToken: ImportTerm : crate::veryl_token::Token Comments; Production { - lhs: 275, - production: &[ParseType::N(95), ParseType::N(274)], + lhs: 272, + production: &[ParseType::N(98), ParseType::N(271)], }, - // 178 - InitialToken: InitialTerm : crate::veryl_token::Token Comments; + // 179 - IncludeToken: IncludeTerm : crate::veryl_token::Token Comments; Production { - lhs: 280, - production: &[ParseType::N(95), ParseType::N(279)], + lhs: 279, + production: &[ParseType::N(98), ParseType::N(278)], }, - // 179 - InoutToken: InoutTerm : crate::veryl_token::Token Comments; + // 180 - InitialToken: InitialTerm : crate::veryl_token::Token Comments; Production { - lhs: 283, - production: &[ParseType::N(95), ParseType::N(282)], + lhs: 284, + production: &[ParseType::N(98), ParseType::N(283)], }, - // 180 - InputToken: InputTerm : crate::veryl_token::Token Comments; + // 181 - InoutToken: InoutTerm : crate::veryl_token::Token Comments; Production { - lhs: 286, - production: &[ParseType::N(95), ParseType::N(285)], + lhs: 287, + production: &[ParseType::N(98), ParseType::N(286)], }, - // 181 - InsideToken: InsideTerm : crate::veryl_token::Token Comments; + // 182 - InputToken: InputTerm : crate::veryl_token::Token Comments; Production { lhs: 290, - production: &[ParseType::N(95), ParseType::N(289)], + production: &[ParseType::N(98), ParseType::N(289)], }, - // 182 - InstToken: InstTerm : crate::veryl_token::Token Comments; + // 183 - InsideToken: InsideTerm : crate::veryl_token::Token Comments; Production { - lhs: 316, - production: &[ParseType::N(95), ParseType::N(315)], + lhs: 294, + production: &[ParseType::N(98), ParseType::N(293)], }, - // 183 - InterfaceToken: InterfaceTerm : crate::veryl_token::Token Comments; + // 184 - InstToken: InstTerm : crate::veryl_token::Token Comments; Production { - lhs: 339, - production: &[ParseType::N(95), ParseType::N(338)], + lhs: 320, + production: &[ParseType::N(98), ParseType::N(319)], }, - // 184 - InToken: InTerm : crate::veryl_token::Token Comments; + // 185 - InterfaceToken: InterfaceTerm : crate::veryl_token::Token Comments; Production { - lhs: 271, - production: &[ParseType::N(95), ParseType::N(270)], + lhs: 344, + production: &[ParseType::N(98), ParseType::N(343)], }, - // 185 - LetToken: LetTerm : crate::veryl_token::Token Comments; + // 186 - InToken: InTerm : crate::veryl_token::Token Comments; Production { - lhs: 356, - production: &[ParseType::N(95), ParseType::N(355)], + lhs: 275, + production: &[ParseType::N(98), ParseType::N(274)], }, - // 186 - LocalToken: LocalTerm : crate::veryl_token::Token Comments; + // 187 - LetToken: LetTerm : crate::veryl_token::Token Comments; Production { lhs: 361, - production: &[ParseType::N(95), ParseType::N(360)], + production: &[ParseType::N(98), ParseType::N(360)], }, - // 187 - LogicToken: LogicTerm : crate::veryl_token::Token Comments; + // 188 - LocalToken: LocalTerm : crate::veryl_token::Token Comments; Production { - lhs: 364, - production: &[ParseType::N(95), ParseType::N(363)], + lhs: 366, + production: &[ParseType::N(98), ParseType::N(365)], }, - // 188 - LsbToken: LsbTerm : crate::veryl_token::Token Comments; + // 189 - LogicToken: LogicTerm : crate::veryl_token::Token Comments; Production { - lhs: 367, - production: &[ParseType::N(95), ParseType::N(366)], + lhs: 369, + production: &[ParseType::N(98), ParseType::N(368)], }, - // 189 - ModportToken: ModportTerm : crate::veryl_token::Token Comments; + // 190 - LsbToken: LsbTerm : crate::veryl_token::Token Comments; Production { - lhs: 384, - production: &[ParseType::N(95), ParseType::N(383)], + lhs: 372, + production: &[ParseType::N(98), ParseType::N(371)], }, - // 190 - ModuleToken: ModuleTerm : crate::veryl_token::Token Comments; + // 191 - ModportToken: ModportTerm : crate::veryl_token::Token Comments; Production { - lhs: 407, - production: &[ParseType::N(95), ParseType::N(406)], + lhs: 389, + production: &[ParseType::N(98), ParseType::N(388)], }, - // 191 - MsbToken: MsbTerm : crate::veryl_token::Token Comments; + // 192 - ModuleToken: ModuleTerm : crate::veryl_token::Token Comments; Production { - lhs: 410, - production: &[ParseType::N(95), ParseType::N(409)], + lhs: 413, + production: &[ParseType::N(98), ParseType::N(412)], }, - // 192 - OutputToken: OutputTerm : crate::veryl_token::Token Comments; + // 193 - MsbToken: MsbTerm : crate::veryl_token::Token Comments; Production { - lhs: 447, - production: &[ParseType::N(95), ParseType::N(446)], + lhs: 416, + production: &[ParseType::N(98), ParseType::N(415)], }, - // 193 - OutsideToken: OutsideTerm : crate::veryl_token::Token Comments; + // 194 - OutputToken: OutputTerm : crate::veryl_token::Token Comments; Production { - lhs: 451, - production: &[ParseType::N(95), ParseType::N(450)], + lhs: 453, + production: &[ParseType::N(98), ParseType::N(452)], }, - // 194 - PackageToken: PackageTerm : crate::veryl_token::Token Comments; + // 195 - OutsideToken: OutsideTerm : crate::veryl_token::Token Comments; Production { - lhs: 462, - production: &[ParseType::N(95), ParseType::N(461)], + lhs: 457, + production: &[ParseType::N(98), ParseType::N(456)], }, - // 195 - ParamToken: ParamTerm : crate::veryl_token::Token Comments; + // 196 - PackageToken: PackageTerm : crate::veryl_token::Token Comments; Production { - lhs: 465, - production: &[ParseType::N(95), ParseType::N(464)], + lhs: 469, + production: &[ParseType::N(98), ParseType::N(468)], }, - // 196 - PubToken: PubTerm : crate::veryl_token::Token Comments; + // 197 - ParamToken: ParamTerm : crate::veryl_token::Token Comments; Production { - lhs: 482, - production: &[ParseType::N(95), ParseType::N(481)], + lhs: 472, + production: &[ParseType::N(98), ParseType::N(471)], }, - // 197 - RefToken: RefTerm : crate::veryl_token::Token Comments; + // 198 - PubToken: PubTerm : crate::veryl_token::Token Comments; Production { - lhs: 508, - production: &[ParseType::N(95), ParseType::N(507)], + lhs: 489, + production: &[ParseType::N(98), ParseType::N(488)], }, - // 198 - RepeatToken: RepeatTerm : crate::veryl_token::Token Comments; + // 199 - RefToken: RefTerm : crate::veryl_token::Token Comments; Production { - lhs: 511, - production: &[ParseType::N(95), ParseType::N(510)], + lhs: 515, + production: &[ParseType::N(98), ParseType::N(514)], }, - // 199 - ResetToken: ResetTerm : crate::veryl_token::Token Comments; + // 200 - RepeatToken: RepeatTerm : crate::veryl_token::Token Comments; Production { - lhs: 526, - production: &[ParseType::N(95), ParseType::N(525)], + lhs: 518, + production: &[ParseType::N(98), ParseType::N(517)], }, - // 200 - ResetAsyncHighToken: ResetAsyncHighTerm : crate::veryl_token::Token Comments; + // 201 - ResetToken: ResetTerm : crate::veryl_token::Token Comments; Production { - lhs: 515, - production: &[ParseType::N(95), ParseType::N(514)], + lhs: 533, + production: &[ParseType::N(98), ParseType::N(532)], }, - // 201 - ResetAsyncLowToken: ResetAsyncLowTerm : crate::veryl_token::Token Comments; + // 202 - ResetAsyncHighToken: ResetAsyncHighTerm : crate::veryl_token::Token Comments; Production { - lhs: 518, - production: &[ParseType::N(95), ParseType::N(517)], + lhs: 522, + production: &[ParseType::N(98), ParseType::N(521)], }, - // 202 - ResetSyncHighToken: ResetSyncHighTerm : crate::veryl_token::Token Comments; + // 203 - ResetAsyncLowToken: ResetAsyncLowTerm : crate::veryl_token::Token Comments; Production { - lhs: 521, - production: &[ParseType::N(95), ParseType::N(520)], + lhs: 525, + production: &[ParseType::N(98), ParseType::N(524)], }, - // 203 - ResetSyncLowToken: ResetSyncLowTerm : crate::veryl_token::Token Comments; + // 204 - ResetSyncHighToken: ResetSyncHighTerm : crate::veryl_token::Token Comments; Production { - lhs: 524, - production: &[ParseType::N(95), ParseType::N(523)], + lhs: 528, + production: &[ParseType::N(98), ParseType::N(527)], }, - // 204 - ReturnToken: ReturnTerm : crate::veryl_token::Token Comments; + // 205 - ResetSyncLowToken: ResetSyncLowTerm : crate::veryl_token::Token Comments; Production { - lhs: 530, - production: &[ParseType::N(95), ParseType::N(529)], + lhs: 531, + production: &[ParseType::N(98), ParseType::N(530)], }, - // 205 - BreakToken: BreakTerm : crate::veryl_token::Token Comments; + // 206 - ReturnToken: ReturnTerm : crate::veryl_token::Token Comments; Production { - lhs: 61, - production: &[ParseType::N(95), ParseType::N(60)], + lhs: 537, + production: &[ParseType::N(98), ParseType::N(536)], }, - // 206 - SignedToken: SignedTerm : crate::veryl_token::Token Comments; + // 207 - BreakToken: BreakTerm : crate::veryl_token::Token Comments; Production { - lhs: 545, - production: &[ParseType::N(95), ParseType::N(544)], + lhs: 61, + production: &[ParseType::N(98), ParseType::N(60)], }, - // 207 - StepToken: StepTerm : crate::veryl_token::Token Comments; + // 208 - SignedToken: SignedTerm : crate::veryl_token::Token Comments; Production { lhs: 554, - production: &[ParseType::N(95), ParseType::N(553)], - }, - // 208 - StringToken: StringTerm : crate::veryl_token::Token Comments; - Production { - lhs: 560, - production: &[ParseType::N(95), ParseType::N(559)], + production: &[ParseType::N(98), ParseType::N(553)], }, - // 209 - StructToken: StructTerm : crate::veryl_token::Token Comments; + // 209 - StepToken: StepTerm : crate::veryl_token::Token Comments; Production { lhs: 563, - production: &[ParseType::N(95), ParseType::N(562)], + production: &[ParseType::N(98), ParseType::N(562)], }, - // 210 - TriToken: TriTerm : crate::veryl_token::Token Comments; + // 210 - StringToken: StringTerm : crate::veryl_token::Token Comments; Production { - lhs: 575, - production: &[ParseType::N(95), ParseType::N(574)], + lhs: 569, + production: &[ParseType::N(98), ParseType::N(568)], }, - // 211 - TypeToken: TypeTerm : crate::veryl_token::Token Comments; + // 211 - StructToken: StructTerm : crate::veryl_token::Token Comments; Production { - lhs: 581, - production: &[ParseType::N(95), ParseType::N(580)], + lhs: 572, + production: &[ParseType::N(98), ParseType::N(571)], }, - // 212 - U32Token: U32Term : crate::veryl_token::Token Comments; + // 212 - TriToken: TriTerm : crate::veryl_token::Token Comments; Production { - lhs: 584, - production: &[ParseType::N(95), ParseType::N(583)], + lhs: 585, + production: &[ParseType::N(98), ParseType::N(584)], }, - // 213 - U64Token: U64Term : crate::veryl_token::Token Comments; + // 213 - TypeToken: TypeTerm : crate::veryl_token::Token Comments; Production { - lhs: 587, - production: &[ParseType::N(95), ParseType::N(586)], + lhs: 591, + production: &[ParseType::N(98), ParseType::N(590)], }, - // 214 - UnionToken: UnionTerm : crate::veryl_token::Token Comments; + // 214 - U32Token: U32Term : crate::veryl_token::Token Comments; Production { - lhs: 593, - production: &[ParseType::N(95), ParseType::N(592)], + lhs: 594, + production: &[ParseType::N(98), ParseType::N(593)], }, - // 215 - VarToken: VarTerm : crate::veryl_token::Token Comments; + // 215 - U64Token: U64Term : crate::veryl_token::Token Comments; Production { lhs: 597, - production: &[ParseType::N(95), ParseType::N(596)], + production: &[ParseType::N(98), ParseType::N(596)], }, - // 216 - DollarIdentifierToken: DollarIdentifierTerm : crate::veryl_token::Token Comments; + // 216 - UnionToken: UnionTerm : crate::veryl_token::Token Comments; Production { - lhs: 114, - production: &[ParseType::N(95), ParseType::N(113)], + lhs: 603, + production: &[ParseType::N(98), ParseType::N(602)], }, - // 217 - IdentifierToken: IdentifierTerm : crate::veryl_token::Token Comments; + // 217 - VarToken: VarTerm : crate::veryl_token::Token Comments; Production { - lhs: 243, - production: &[ParseType::N(95), ParseType::N(242)], + lhs: 607, + production: &[ParseType::N(98), ParseType::N(606)], }, - // 218 - Start: StartToken : crate::veryl_token::VerylToken ; + // 218 - DollarIdentifierToken: DollarIdentifierTerm : crate::veryl_token::Token Comments; Production { - lhs: 549, - production: &[ParseType::N(550)], + lhs: 117, + production: &[ParseType::N(98), ParseType::N(116)], }, - // 219 - StringLiteral: StringLiteralToken : crate::veryl_token::VerylToken ; + // 219 - IdentifierToken: IdentifierTerm : crate::veryl_token::Token Comments; Production { - lhs: 556, - production: &[ParseType::N(558)], + lhs: 247, + production: &[ParseType::N(98), ParseType::N(246)], }, - // 220 - Exponent: ExponentToken : crate::veryl_token::VerylToken ; + // 220 - Start: StartToken : crate::veryl_token::VerylToken ; Production { - lhs: 151, - production: &[ParseType::N(153)], + lhs: 558, + production: &[ParseType::N(559)], }, - // 221 - FixedPoint: FixedPointToken : crate::veryl_token::VerylToken ; + // 221 - StringLiteral: StringLiteralToken : crate::veryl_token::VerylToken ; Production { - lhs: 206, - production: &[ParseType::N(208)], + lhs: 565, + production: &[ParseType::N(567)], + }, + // 222 - Exponent: ExponentToken : crate::veryl_token::VerylToken ; + Production { + lhs: 154, + production: &[ParseType::N(156)], + }, + // 223 - FixedPoint: FixedPointToken : crate::veryl_token::VerylToken ; + Production { + lhs: 209, + production: &[ParseType::N(211)], }, - // 222 - Based: BasedToken : crate::veryl_token::VerylToken ; + // 224 - Based: BasedToken : crate::veryl_token::VerylToken ; Production { lhs: 52, production: &[ParseType::N(54)], }, - // 223 - BaseLess: BaseLessToken : crate::veryl_token::VerylToken ; + // 225 - BaseLess: BaseLessToken : crate::veryl_token::VerylToken ; Production { lhs: 49, production: &[ParseType::N(51)], }, - // 224 - AllBit: AllBitToken : crate::veryl_token::VerylToken ; + // 226 - AllBit: AllBitToken : crate::veryl_token::VerylToken ; Production { lhs: 0, production: &[ParseType::N(2)], }, - // 225 - AssignmentOperator: AssignmentOperatorToken : crate::veryl_token::VerylToken ; + // 227 - AssignmentOperator: AssignmentOperatorToken : crate::veryl_token::VerylToken ; Production { lhs: 40, production: &[ParseType::N(42)], }, - // 226 - Operator01: Operator01Token : crate::veryl_token::VerylToken ; - Production { - lhs: 412, - production: &[ParseType::N(414)], - }, - // 227 - Operator02: Operator02Token : crate::veryl_token::VerylToken ; - Production { - lhs: 415, - production: &[ParseType::N(417)], - }, - // 228 - Operator03: Operator03Token : crate::veryl_token::VerylToken ; + // 228 - Operator01: Operator01Token : crate::veryl_token::VerylToken ; Production { lhs: 418, production: &[ParseType::N(420)], }, - // 229 - Operator04: Operator04Token : crate::veryl_token::VerylToken ; + // 229 - Operator02: Operator02Token : crate::veryl_token::VerylToken ; Production { lhs: 421, production: &[ParseType::N(423)], }, - // 230 - Operator05: Operator05Token : crate::veryl_token::VerylToken ; + // 230 - Operator03: Operator03Token : crate::veryl_token::VerylToken ; Production { lhs: 424, production: &[ParseType::N(426)], }, - // 231 - Operator06: Operator06Token : crate::veryl_token::VerylToken ; + // 231 - Operator04: Operator04Token : crate::veryl_token::VerylToken ; Production { lhs: 427, production: &[ParseType::N(429)], }, - // 232 - Operator07: Operator07Token : crate::veryl_token::VerylToken ; + // 232 - Operator05: Operator05Token : crate::veryl_token::VerylToken ; Production { lhs: 430, production: &[ParseType::N(432)], }, - // 233 - Operator08: Operator08Token : crate::veryl_token::VerylToken ; + // 233 - Operator06: Operator06Token : crate::veryl_token::VerylToken ; Production { lhs: 433, production: &[ParseType::N(435)], }, - // 234 - Operator09: Operator09Token : crate::veryl_token::VerylToken ; + // 234 - Operator07: Operator07Token : crate::veryl_token::VerylToken ; Production { lhs: 436, production: &[ParseType::N(438)], }, - // 235 - Operator10: Operator10Token : crate::veryl_token::VerylToken ; + // 235 - Operator08: Operator08Token : crate::veryl_token::VerylToken ; Production { lhs: 439, production: &[ParseType::N(441)], }, - // 236 - Operator11: Operator11Token : crate::veryl_token::VerylToken ; + // 236 - Operator09: Operator09Token : crate::veryl_token::VerylToken ; Production { lhs: 442, production: &[ParseType::N(444)], }, - // 237 - UnaryOperator: UnaryOperatorToken : crate::veryl_token::VerylToken ; + // 237 - Operator10: Operator10Token : crate::veryl_token::VerylToken ; Production { - lhs: 588, - production: &[ParseType::N(590)], + lhs: 445, + production: &[ParseType::N(447)], + }, + // 238 - Operator11: Operator11Token : crate::veryl_token::VerylToken ; + Production { + lhs: 448, + production: &[ParseType::N(450)], + }, + // 239 - UnaryOperator: UnaryOperatorToken : crate::veryl_token::VerylToken ; + Production { + lhs: 598, + production: &[ParseType::N(600)], }, - // 238 - Colon: ColonToken : crate::veryl_token::VerylToken ; + // 240 - Colon: ColonToken : crate::veryl_token::VerylToken ; Production { lhs: 86, - production: &[ParseType::N(91)], + production: &[ParseType::N(94)], + }, + // 241 - ColonColonLAngle: ColonColonLAngleToken : crate::veryl_token::VerylToken ; + Production { + lhs: 88, + production: &[ParseType::N(90)], }, - // 239 - ColonColon: ColonColonToken : crate::veryl_token::VerylToken ; + // 242 - ColonColon: ColonColonToken : crate::veryl_token::VerylToken ; Production { lhs: 87, - production: &[ParseType::N(89)], + production: &[ParseType::N(92)], }, - // 240 - Comma: CommaToken : crate::veryl_token::VerylToken ; + // 243 - Comma: CommaToken : crate::veryl_token::VerylToken ; Production { - lhs: 92, - production: &[ParseType::N(94)], + lhs: 95, + production: &[ParseType::N(97)], }, - // 241 - DotDot: DotDotToken : crate::veryl_token::VerylToken ; + // 244 - DotDot: DotDotToken : crate::veryl_token::VerylToken ; Production { - lhs: 116, - production: &[ParseType::N(121)], + lhs: 119, + production: &[ParseType::N(124)], }, - // 242 - DotDotEqu: DotDotEquToken : crate::veryl_token::VerylToken ; + // 245 - DotDotEqu: DotDotEquToken : crate::veryl_token::VerylToken ; Production { - lhs: 117, - production: &[ParseType::N(119)], + lhs: 120, + production: &[ParseType::N(122)], }, - // 243 - Dot: DotToken : crate::veryl_token::VerylToken ; + // 246 - Dot: DotToken : crate::veryl_token::VerylToken ; Production { - lhs: 115, - production: &[ParseType::N(123)], + lhs: 118, + production: &[ParseType::N(126)], }, - // 244 - Equ: EquToken : crate::veryl_token::VerylToken ; + // 247 - Equ: EquToken : crate::veryl_token::VerylToken ; Production { - lhs: 148, - production: &[ParseType::N(150)], + lhs: 151, + production: &[ParseType::N(153)], }, - // 245 - Hash: HashToken : crate::veryl_token::VerylToken ; + // 248 - Hash: HashToken : crate::veryl_token::VerylToken ; Production { - lhs: 226, - production: &[ParseType::N(228)], + lhs: 230, + production: &[ParseType::N(232)], }, - // 246 - QuoteLBrace: QuoteLBraceToken : crate::veryl_token::VerylToken ; + // 249 - QuoteLBrace: QuoteLBraceToken : crate::veryl_token::VerylToken ; Production { - lhs: 483, - production: &[ParseType::N(485)], + lhs: 490, + production: &[ParseType::N(492)], }, - // 247 - LAngle: LAngleToken : crate::veryl_token::VerylToken ; + // 250 - LAngle: LAngleToken : crate::veryl_token::VerylToken ; Production { - lhs: 340, - production: &[ParseType::N(342)], + lhs: 345, + production: &[ParseType::N(347)], }, - // 248 - LBrace: LBraceToken : crate::veryl_token::VerylToken ; + // 251 - LBrace: LBraceToken : crate::veryl_token::VerylToken ; Production { - lhs: 343, - production: &[ParseType::N(345)], + lhs: 348, + production: &[ParseType::N(350)], }, - // 249 - LBracket: LBracketToken : crate::veryl_token::VerylToken ; + // 252 - LBracket: LBracketToken : crate::veryl_token::VerylToken ; Production { - lhs: 346, - production: &[ParseType::N(348)], + lhs: 351, + production: &[ParseType::N(353)], }, - // 250 - LParen: LParenToken : crate::veryl_token::VerylToken ; + // 253 - LParen: LParenToken : crate::veryl_token::VerylToken ; Production { - lhs: 349, - production: &[ParseType::N(351)], + lhs: 354, + production: &[ParseType::N(356)], }, - // 251 - MinusColon: MinusColonToken : crate::veryl_token::VerylToken ; + // 254 - MinusColon: MinusColonToken : crate::veryl_token::VerylToken ; Production { - lhs: 368, - production: &[ParseType::N(370)], + lhs: 373, + production: &[ParseType::N(375)], }, - // 252 - MinusGT: MinusGTToken : crate::veryl_token::VerylToken ; + // 255 - MinusGT: MinusGTToken : crate::veryl_token::VerylToken ; Production { - lhs: 371, - production: &[ParseType::N(373)], + lhs: 376, + production: &[ParseType::N(378)], }, - // 253 - PlusColon: PlusColonToken : crate::veryl_token::VerylToken ; + // 256 - PlusColon: PlusColonToken : crate::veryl_token::VerylToken ; Production { - lhs: 466, - production: &[ParseType::N(468)], + lhs: 473, + production: &[ParseType::N(475)], }, - // 254 - RAngle: RAngleToken : crate::veryl_token::VerylToken ; + // 257 - RAngle: RAngleToken : crate::veryl_token::VerylToken ; Production { - lhs: 486, - production: &[ParseType::N(488)], + lhs: 493, + production: &[ParseType::N(495)], }, - // 255 - RBrace: RBraceToken : crate::veryl_token::VerylToken ; + // 258 - RBrace: RBraceToken : crate::veryl_token::VerylToken ; Production { - lhs: 489, - production: &[ParseType::N(491)], + lhs: 496, + production: &[ParseType::N(498)], }, - // 256 - RBracket: RBracketToken : crate::veryl_token::VerylToken ; + // 259 - RBracket: RBracketToken : crate::veryl_token::VerylToken ; Production { - lhs: 492, - production: &[ParseType::N(494)], + lhs: 499, + production: &[ParseType::N(501)], }, - // 257 - RParen: RParenToken : crate::veryl_token::VerylToken ; + // 260 - RParen: RParenToken : crate::veryl_token::VerylToken ; Production { - lhs: 495, - production: &[ParseType::N(497)], + lhs: 502, + production: &[ParseType::N(504)], }, - // 258 - Semicolon: SemicolonToken : crate::veryl_token::VerylToken ; + // 261 - Semicolon: SemicolonToken : crate::veryl_token::VerylToken ; Production { - lhs: 540, - production: &[ParseType::N(542)], + lhs: 549, + production: &[ParseType::N(551)], }, - // 259 - Star: StarToken : crate::veryl_token::VerylToken ; + // 262 - Star: StarToken : crate::veryl_token::VerylToken ; Production { - lhs: 546, - production: &[ParseType::N(548)], + lhs: 555, + production: &[ParseType::N(557)], }, - // 260 - AlwaysComb: AlwaysCombToken : crate::veryl_token::VerylToken ; + // 263 - AlwaysComb: AlwaysCombToken : crate::veryl_token::VerylToken ; Production { lhs: 3, production: &[ParseType::N(7)], }, - // 261 - AlwaysFf: AlwaysFfToken : crate::veryl_token::VerylToken ; + // 264 - AlwaysFf: AlwaysFfToken : crate::veryl_token::VerylToken ; Production { lhs: 8, production: &[ParseType::N(15)], }, - // 262 - As: AsToken : crate::veryl_token::VerylToken ; + // 265 - As: AsToken : crate::veryl_token::VerylToken ; Production { lhs: 31, production: &[ParseType::N(33)], }, - // 263 - Assign: AssignToken : crate::veryl_token::VerylToken ; + // 266 - Assign: AssignToken : crate::veryl_token::VerylToken ; Production { lhs: 34, production: &[ParseType::N(37)], }, - // 264 - Bit: BitToken : crate::veryl_token::VerylToken ; + // 267 - Bit: BitToken : crate::veryl_token::VerylToken ; Production { lhs: 55, production: &[ParseType::N(57)], }, - // 265 - Break: BreakToken : crate::veryl_token::VerylToken ; + // 268 - Break: BreakToken : crate::veryl_token::VerylToken ; Production { lhs: 58, production: &[ParseType::N(61)], }, - // 266 - Case: CaseToken : crate::veryl_token::VerylToken ; + // 269 - Case: CaseToken : crate::veryl_token::VerylToken ; Production { lhs: 62, production: &[ParseType::N(76)], }, - // 267 - Clock: ClockToken : crate::veryl_token::VerylToken ; + // 270 - Clock: ClockToken : crate::veryl_token::VerylToken ; Production { lhs: 77, production: &[ParseType::N(85)], }, - // 268 - ClockPosedge: ClockPosedgeToken : crate::veryl_token::VerylToken ; + // 271 - ClockPosedge: ClockPosedgeToken : crate::veryl_token::VerylToken ; Production { lhs: 81, production: &[ParseType::N(83)], }, - // 269 - ClockNegedge: ClockNegedgeToken : crate::veryl_token::VerylToken ; + // 272 - ClockNegedge: ClockNegedgeToken : crate::veryl_token::VerylToken ; Production { lhs: 78, production: &[ParseType::N(80)], }, - // 270 - Defaul: DefaultToken : crate::veryl_token::VerylToken ; - Production { - lhs: 103, - production: &[ParseType::N(105)], - }, - // 271 - Else: ElseToken : crate::veryl_token::VerylToken ; + // 273 - Defaul: DefaultToken : crate::veryl_token::VerylToken ; Production { - lhs: 124, - production: &[ParseType::N(126)], + lhs: 106, + production: &[ParseType::N(108)], }, - // 272 - Embed: EmbedToken : crate::veryl_token::VerylToken ; + // 274 - Else: ElseToken : crate::veryl_token::VerylToken ; Production { lhs: 127, - production: &[ParseType::N(135)], + production: &[ParseType::N(129)], }, - // 273 - Enum: EnumToken : crate::veryl_token::VerylToken ; + // 275 - Embed: EmbedToken : crate::veryl_token::VerylToken ; Production { - lhs: 136, - production: &[ParseType::N(147)], + lhs: 130, + production: &[ParseType::N(138)], }, - // 274 - Export: ExportToken : crate::veryl_token::VerylToken ; + // 276 - Enum: EnumToken : crate::veryl_token::VerylToken ; Production { - lhs: 154, - production: &[ParseType::N(159)], + lhs: 139, + production: &[ParseType::N(150)], }, - // 275 - F32: F32Token : crate::veryl_token::VerylToken ; + // 277 - Export: ExportToken : crate::veryl_token::VerylToken ; Production { - lhs: 192, - production: &[ParseType::N(194)], + lhs: 157, + production: &[ParseType::N(162)], }, - // 276 - F64: F64Token : crate::veryl_token::VerylToken ; + // 278 - F32: F32Token : crate::veryl_token::VerylToken ; Production { lhs: 195, production: &[ParseType::N(197)], }, - // 277 - Final: FinalToken : crate::veryl_token::VerylToken ; + // 279 - F64: F64Token : crate::veryl_token::VerylToken ; Production { - lhs: 201, - production: &[ParseType::N(205)], + lhs: 198, + production: &[ParseType::N(200)], }, - // 278 - For: ForToken : crate::veryl_token::VerylToken ; + // 280 - Final: FinalToken : crate::veryl_token::VerylToken ; Production { - lhs: 210, - production: &[ParseType::N(215)], + lhs: 204, + production: &[ParseType::N(208)], }, - // 279 - Function: FunctionToken : crate::veryl_token::VerylToken ; + // 281 - For: ForToken : crate::veryl_token::VerylToken ; Production { - lhs: 216, - production: &[ParseType::N(225)], + lhs: 213, + production: &[ParseType::N(218)], }, - // 280 - I32: I32Token : crate::veryl_token::VerylToken ; + // 282 - Function: FunctionToken : crate::veryl_token::VerylToken ; Production { - lhs: 233, - production: &[ParseType::N(235)], + lhs: 219, + production: &[ParseType::N(229)], }, - // 281 - I64: I64Token : crate::veryl_token::VerylToken ; + // 283 - I32: I32Token : crate::veryl_token::VerylToken ; Production { - lhs: 236, - production: &[ParseType::N(238)], + lhs: 237, + production: &[ParseType::N(239)], }, - // 282 - If: IfToken : crate::veryl_token::VerylToken ; + // 284 - I64: I64Token : crate::veryl_token::VerylToken ; Production { - lhs: 244, - production: &[ParseType::N(263)], + lhs: 240, + production: &[ParseType::N(242)], }, - // 283 - IfReset: IfResetToken : crate::veryl_token::VerylToken ; + // 285 - If: IfToken : crate::veryl_token::VerylToken ; Production { - lhs: 247, - production: &[ParseType::N(255)], + lhs: 248, + production: &[ParseType::N(267)], }, - // 284 - Import: ImportToken : crate::veryl_token::VerylToken ; + // 286 - IfReset: IfResetToken : crate::veryl_token::VerylToken ; Production { - lhs: 264, - production: &[ParseType::N(268)], + lhs: 251, + production: &[ParseType::N(259)], }, - // 285 - In: InToken : crate::veryl_token::VerylToken ; + // 287 - Import: ImportToken : crate::veryl_token::VerylToken ; Production { - lhs: 269, - production: &[ParseType::N(271)], + lhs: 268, + production: &[ParseType::N(272)], }, - // 286 - Include: IncludeToken : crate::veryl_token::VerylToken ; + // 288 - In: InToken : crate::veryl_token::VerylToken ; Production { - lhs: 272, + lhs: 273, production: &[ParseType::N(275)], }, - // 287 - Initial: InitialToken : crate::veryl_token::VerylToken ; + // 289 - Include: IncludeToken : crate::veryl_token::VerylToken ; Production { lhs: 276, - production: &[ParseType::N(280)], + production: &[ParseType::N(279)], }, - // 288 - Inout: InoutToken : crate::veryl_token::VerylToken ; + // 290 - Initial: InitialToken : crate::veryl_token::VerylToken ; Production { - lhs: 281, - production: &[ParseType::N(283)], + lhs: 280, + production: &[ParseType::N(284)], }, - // 289 - Input: InputToken : crate::veryl_token::VerylToken ; + // 291 - Inout: InoutToken : crate::veryl_token::VerylToken ; Production { - lhs: 284, - production: &[ParseType::N(286)], + lhs: 285, + production: &[ParseType::N(287)], }, - // 290 - Inside: InsideToken : crate::veryl_token::VerylToken ; + // 292 - Input: InputToken : crate::veryl_token::VerylToken ; Production { - lhs: 287, + lhs: 288, production: &[ParseType::N(290)], }, - // 291 - Inst: InstToken : crate::veryl_token::VerylToken ; + // 293 - Inside: InsideToken : crate::veryl_token::VerylToken ; Production { lhs: 291, - production: &[ParseType::N(316)], + production: &[ParseType::N(294)], }, - // 292 - Interface: InterfaceToken : crate::veryl_token::VerylToken ; + // 294 - Inst: InstToken : crate::veryl_token::VerylToken ; Production { - lhs: 318, - production: &[ParseType::N(339)], + lhs: 295, + production: &[ParseType::N(320)], }, - // 293 - Let: LetToken : crate::veryl_token::VerylToken ; + // 295 - Interface: InterfaceToken : crate::veryl_token::VerylToken ; Production { - lhs: 352, - production: &[ParseType::N(356)], + lhs: 322, + production: &[ParseType::N(344)], }, - // 294 - Local: LocalToken : crate::veryl_token::VerylToken ; + // 296 - Let: LetToken : crate::veryl_token::VerylToken ; Production { lhs: 357, production: &[ParseType::N(361)], }, - // 295 - Logic: LogicToken : crate::veryl_token::VerylToken ; + // 297 - Local: LocalToken : crate::veryl_token::VerylToken ; Production { lhs: 362, - production: &[ParseType::N(364)], - }, - // 296 - Lsb: LsbToken : crate::veryl_token::VerylToken ; - Production { - lhs: 365, - production: &[ParseType::N(367)], - }, - // 297 - Modport: ModportToken : crate::veryl_token::VerylToken ; - Production { - lhs: 374, - production: &[ParseType::N(384)], + production: &[ParseType::N(366)], }, - // 298 - Module: ModuleToken : crate::veryl_token::VerylToken ; + // 298 - Logic: LogicToken : crate::veryl_token::VerylToken ; Production { - lhs: 385, - production: &[ParseType::N(407)], + lhs: 367, + production: &[ParseType::N(369)], }, - // 299 - Msb: MsbToken : crate::veryl_token::VerylToken ; + // 299 - Lsb: LsbToken : crate::veryl_token::VerylToken ; Production { - lhs: 408, - production: &[ParseType::N(410)], + lhs: 370, + production: &[ParseType::N(372)], }, - // 300 - Output: OutputToken : crate::veryl_token::VerylToken ; + // 300 - Modport: ModportToken : crate::veryl_token::VerylToken ; Production { - lhs: 445, - production: &[ParseType::N(447)], + lhs: 379, + production: &[ParseType::N(389)], }, - // 301 - Outside: OutsideToken : crate::veryl_token::VerylToken ; + // 301 - Module: ModuleToken : crate::veryl_token::VerylToken ; Production { - lhs: 448, - production: &[ParseType::N(451)], + lhs: 390, + production: &[ParseType::N(413)], }, - // 302 - Package: PackageToken : crate::veryl_token::VerylToken ; + // 302 - Msb: MsbToken : crate::veryl_token::VerylToken ; Production { - lhs: 452, - production: &[ParseType::N(462)], + lhs: 414, + production: &[ParseType::N(416)], }, - // 303 - Param: ParamToken : crate::veryl_token::VerylToken ; + // 303 - Output: OutputToken : crate::veryl_token::VerylToken ; Production { - lhs: 463, - production: &[ParseType::N(465)], + lhs: 451, + production: &[ParseType::N(453)], }, - // 304 - Pub: PubToken : crate::veryl_token::VerylToken ; + // 304 - Outside: OutsideToken : crate::veryl_token::VerylToken ; Production { - lhs: 480, - production: &[ParseType::N(482)], + lhs: 454, + production: &[ParseType::N(457)], }, - // 305 - Ref: RefToken : crate::veryl_token::VerylToken ; + // 305 - Package: PackageToken : crate::veryl_token::VerylToken ; Production { - lhs: 506, - production: &[ParseType::N(508)], + lhs: 458, + production: &[ParseType::N(469)], }, - // 306 - Repeat: RepeatToken : crate::veryl_token::VerylToken ; + // 306 - Param: ParamToken : crate::veryl_token::VerylToken ; Production { - lhs: 509, - production: &[ParseType::N(511)], + lhs: 470, + production: &[ParseType::N(472)], }, - // 307 - Reset: ResetToken : crate::veryl_token::VerylToken ; + // 307 - Pub: PubToken : crate::veryl_token::VerylToken ; Production { - lhs: 512, - production: &[ParseType::N(526)], + lhs: 487, + production: &[ParseType::N(489)], }, - // 308 - ResetAsyncHigh: ResetAsyncHighToken : crate::veryl_token::VerylToken ; + // 308 - Ref: RefToken : crate::veryl_token::VerylToken ; Production { lhs: 513, production: &[ParseType::N(515)], }, - // 309 - ResetAsyncLow: ResetAsyncLowToken : crate::veryl_token::VerylToken ; + // 309 - Repeat: RepeatToken : crate::veryl_token::VerylToken ; Production { lhs: 516, production: &[ParseType::N(518)], }, - // 310 - ResetSyncHigh: ResetSyncHighToken : crate::veryl_token::VerylToken ; + // 310 - Reset: ResetToken : crate::veryl_token::VerylToken ; Production { lhs: 519, - production: &[ParseType::N(521)], + production: &[ParseType::N(533)], }, - // 311 - ResetSyncLow: ResetSyncLowToken : crate::veryl_token::VerylToken ; + // 311 - ResetAsyncHigh: ResetAsyncHighToken : crate::veryl_token::VerylToken ; Production { - lhs: 522, - production: &[ParseType::N(524)], + lhs: 520, + production: &[ParseType::N(522)], }, - // 312 - Return: ReturnToken : crate::veryl_token::VerylToken ; + // 312 - ResetAsyncLow: ResetAsyncLowToken : crate::veryl_token::VerylToken ; Production { - lhs: 527, - production: &[ParseType::N(530)], + lhs: 523, + production: &[ParseType::N(525)], }, - // 313 - Signed: SignedToken : crate::veryl_token::VerylToken ; + // 313 - ResetSyncHigh: ResetSyncHighToken : crate::veryl_token::VerylToken ; Production { - lhs: 543, - production: &[ParseType::N(545)], + lhs: 526, + production: &[ParseType::N(528)], }, - // 314 - Step: StepToken : crate::veryl_token::VerylToken ; + // 314 - ResetSyncLow: ResetSyncLowToken : crate::veryl_token::VerylToken ; Production { - lhs: 552, - production: &[ParseType::N(554)], + lhs: 529, + production: &[ParseType::N(531)], }, - // 315 - Strin: StringToken : crate::veryl_token::VerylToken ; + // 315 - Return: ReturnToken : crate::veryl_token::VerylToken ; Production { - lhs: 555, - production: &[ParseType::N(560)], + lhs: 534, + production: &[ParseType::N(537)], + }, + // 316 - Signed: SignedToken : crate::veryl_token::VerylToken ; + Production { + lhs: 552, + production: &[ParseType::N(554)], }, - // 316 - Struct: StructToken : crate::veryl_token::VerylToken ; + // 317 - Step: StepToken : crate::veryl_token::VerylToken ; Production { lhs: 561, production: &[ParseType::N(563)], }, - // 317 - Tri: TriToken : crate::veryl_token::VerylToken ; + // 318 - Strin: StringToken : crate::veryl_token::VerylToken ; Production { - lhs: 573, - production: &[ParseType::N(575)], + lhs: 564, + production: &[ParseType::N(569)], }, - // 318 - Type: TypeToken : crate::veryl_token::VerylToken ; + // 319 - Struct: StructToken : crate::veryl_token::VerylToken ; Production { - lhs: 576, - production: &[ParseType::N(581)], + lhs: 570, + production: &[ParseType::N(572)], }, - // 319 - U32: U32Token : crate::veryl_token::VerylToken ; + // 320 - Tri: TriToken : crate::veryl_token::VerylToken ; Production { - lhs: 582, - production: &[ParseType::N(584)], + lhs: 583, + production: &[ParseType::N(585)], }, - // 320 - U64: U64Token : crate::veryl_token::VerylToken ; + // 321 - Type: TypeToken : crate::veryl_token::VerylToken ; Production { - lhs: 585, - production: &[ParseType::N(587)], + lhs: 586, + production: &[ParseType::N(591)], }, - // 321 - Union: UnionToken : crate::veryl_token::VerylToken ; + // 322 - U32: U32Token : crate::veryl_token::VerylToken ; Production { - lhs: 591, - production: &[ParseType::N(593)], + lhs: 592, + production: &[ParseType::N(594)], }, - // 322 - Var: VarToken : crate::veryl_token::VerylToken ; + // 323 - U64: U64Token : crate::veryl_token::VerylToken ; Production { - lhs: 594, + lhs: 595, production: &[ParseType::N(597)], }, - // 323 - DollarIdentifier: DollarIdentifierToken : crate::veryl_token::VerylToken ; + // 324 - Union: UnionToken : crate::veryl_token::VerylToken ; Production { - lhs: 112, - production: &[ParseType::N(114)], + lhs: 601, + production: &[ParseType::N(603)], }, - // 324 - Identifier: IdentifierToken : crate::veryl_token::VerylToken ; + // 325 - Var: VarToken : crate::veryl_token::VerylToken ; Production { - lhs: 239, - production: &[ParseType::N(243)], + lhs: 604, + production: &[ParseType::N(607)], }, - // 325 - Number: IntegralNumber; + // 326 - DollarIdentifier: DollarIdentifierToken : crate::veryl_token::VerylToken ; Production { - lhs: 411, - production: &[ParseType::N(317)], + lhs: 115, + production: &[ParseType::N(117)], }, - // 326 - Number: RealNumber; + // 327 - Identifier: IdentifierToken : crate::veryl_token::VerylToken ; Production { - lhs: 411, - production: &[ParseType::N(505)], + lhs: 243, + production: &[ParseType::N(247)], }, - // 327 - IntegralNumber: Based; + // 328 - Number: IntegralNumber; Production { - lhs: 317, + lhs: 417, + production: &[ParseType::N(321)], + }, + // 329 - Number: RealNumber; + Production { + lhs: 417, + production: &[ParseType::N(512)], + }, + // 330 - IntegralNumber: Based; + Production { + lhs: 321, production: &[ParseType::N(52)], }, - // 328 - IntegralNumber: BaseLess; + // 331 - IntegralNumber: BaseLess; Production { - lhs: 317, + lhs: 321, production: &[ParseType::N(49)], }, - // 329 - IntegralNumber: AllBit; + // 332 - IntegralNumber: AllBit; Production { - lhs: 317, + lhs: 321, production: &[ParseType::N(0)], }, - // 330 - RealNumber: FixedPoint; + // 333 - RealNumber: FixedPoint; Production { - lhs: 505, - production: &[ParseType::N(206)], + lhs: 512, + production: &[ParseType::N(209)], }, - // 331 - RealNumber: Exponent; + // 334 - RealNumber: Exponent; Production { - lhs: 505, - production: &[ParseType::N(151)], + lhs: 512, + production: &[ParseType::N(154)], }, - // 332 - HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */; + // 335 - HierarchicalIdentifier: Identifier HierarchicalIdentifierList /* Vec */ HierarchicalIdentifierList0 /* Vec */; Production { - lhs: 229, - production: &[ParseType::N(231), ParseType::N(230), ParseType::N(239)], + lhs: 233, + production: &[ParseType::N(235), ParseType::N(234), ParseType::N(243)], }, - // 333 - HierarchicalIdentifierList0: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0; + // 336 - HierarchicalIdentifierList0: Dot Identifier HierarchicalIdentifierList0List /* Vec */ HierarchicalIdentifierList0; Production { - lhs: 231, + lhs: 235, production: &[ - ParseType::N(231), - ParseType::N(232), - ParseType::N(239), - ParseType::N(115), + ParseType::N(235), + ParseType::N(236), + ParseType::N(243), + ParseType::N(118), ], }, - // 334 - HierarchicalIdentifierList0List: Select HierarchicalIdentifierList0List; + // 337 - HierarchicalIdentifierList0List: Select HierarchicalIdentifierList0List; Production { - lhs: 232, - production: &[ParseType::N(232), ParseType::N(537)], + lhs: 236, + production: &[ParseType::N(236), ParseType::N(546)], }, - // 335 - HierarchicalIdentifierList0List: ; + // 338 - HierarchicalIdentifierList0List: ; Production { - lhs: 232, + lhs: 236, production: &[], }, - // 336 - HierarchicalIdentifierList0: ; + // 339 - HierarchicalIdentifierList0: ; Production { - lhs: 231, + lhs: 235, production: &[], }, - // 337 - HierarchicalIdentifierList: Select HierarchicalIdentifierList; + // 340 - HierarchicalIdentifierList: Select HierarchicalIdentifierList; Production { - lhs: 230, - production: &[ParseType::N(230), ParseType::N(537)], + lhs: 234, + production: &[ParseType::N(234), ParseType::N(546)], }, - // 338 - HierarchicalIdentifierList: ; + // 341 - HierarchicalIdentifierList: ; Production { - lhs: 230, + lhs: 234, production: &[], }, - // 339 - ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */; + // 342 - ScopedIdentifier: ScopedIdentifierGroup ScopedIdentifierList /* Vec */; Production { - lhs: 534, - production: &[ParseType::N(536), ParseType::N(535)], + lhs: 541, + production: &[ParseType::N(543), ParseType::N(542)], }, - // 340 - ScopedIdentifierGroup: DollarIdentifier; + // 343 - ScopedIdentifierGroup: DollarIdentifier; Production { - lhs: 535, - production: &[ParseType::N(112)], + lhs: 542, + production: &[ParseType::N(115)], }, - // 341 - ScopedIdentifierGroup: Identifier; + // 344 - ScopedIdentifierGroup: Identifier ScopedIdentifierOpt /* Option */; Production { - lhs: 535, - production: &[ParseType::N(239)], + lhs: 542, + production: &[ParseType::N(544), ParseType::N(243)], }, - // 342 - ScopedIdentifierList: ColonColon Identifier ScopedIdentifierList; + // 345 - ScopedIdentifierList: ColonColon Identifier ScopedIdentifierOpt0 /* Option */ ScopedIdentifierList; Production { - lhs: 536, - production: &[ParseType::N(536), ParseType::N(239), ParseType::N(87)], + lhs: 543, + production: &[ + ParseType::N(543), + ParseType::N(545), + ParseType::N(243), + ParseType::N(87), + ], }, - // 343 - ScopedIdentifierList: ; + // 346 - ScopedIdentifierList: ; Production { - lhs: 536, + lhs: 543, production: &[], }, - // 344 - ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */; + // 347 - ScopedIdentifierOpt0: WithGenericArgument; Production { - lhs: 187, - production: &[ParseType::N(189), ParseType::N(188), ParseType::N(534)], + lhs: 545, + production: &[ParseType::N(615)], }, - // 345 - ExpressionIdentifierList0: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0; + // 348 - ScopedIdentifierOpt0: ; Production { - lhs: 189, - production: &[ - ParseType::N(189), - ParseType::N(190), - ParseType::N(239), - ParseType::N(115), - ], + lhs: 545, + production: &[], }, - // 346 - ExpressionIdentifierList0List: Select ExpressionIdentifierList0List; + // 349 - ScopedIdentifierOpt: WithGenericArgument; Production { - lhs: 190, - production: &[ParseType::N(190), ParseType::N(537)], + lhs: 544, + production: &[ParseType::N(615)], }, - // 347 - ExpressionIdentifierList0List: ; + // 350 - ScopedIdentifierOpt: ; Production { - lhs: 190, + lhs: 544, production: &[], }, - // 348 - ExpressionIdentifierList0: ; + // 351 - ExpressionIdentifier: ScopedIdentifier ExpressionIdentifierList /* Vec */ ExpressionIdentifierList0 /* Vec */; Production { - lhs: 189, - production: &[], + lhs: 190, + production: &[ParseType::N(192), ParseType::N(191), ParseType::N(541)], }, - // 349 - ExpressionIdentifierList: Select ExpressionIdentifierList; + // 352 - ExpressionIdentifierList0: Dot Identifier ExpressionIdentifierList0List /* Vec */ ExpressionIdentifierList0; Production { - lhs: 188, - production: &[ParseType::N(188), ParseType::N(537)], + lhs: 192, + production: &[ + ParseType::N(192), + ParseType::N(193), + ParseType::N(243), + ParseType::N(118), + ], }, - // 350 - ExpressionIdentifierList: ; + // 353 - ExpressionIdentifierList0List: Select ExpressionIdentifierList0List; Production { - lhs: 188, + lhs: 193, + production: &[ParseType::N(193), ParseType::N(546)], + }, + // 354 - ExpressionIdentifierList0List: ; + Production { + lhs: 193, production: &[], }, - // 351 - Expression: Expression01 ExpressionList /* Vec */; + // 355 - ExpressionIdentifierList0: ; Production { - lhs: 160, - production: &[ParseType::N(191), ParseType::N(161)], + lhs: 192, + production: &[], }, - // 352 - ExpressionList: Operator01 Expression01 ExpressionList; + // 356 - ExpressionIdentifierList: Select ExpressionIdentifierList; Production { lhs: 191, - production: &[ParseType::N(191), ParseType::N(161), ParseType::N(412)], + production: &[ParseType::N(191), ParseType::N(546)], }, - // 353 - ExpressionList: ; + // 357 - ExpressionIdentifierList: ; Production { lhs: 191, production: &[], }, - // 354 - Expression01: Expression02 Expression01List /* Vec */; + // 358 - Expression: Expression01 ExpressionList /* Vec */; Production { - lhs: 161, - production: &[ParseType::N(162), ParseType::N(163)], + lhs: 163, + production: &[ParseType::N(194), ParseType::N(164)], }, - // 355 - Expression01List: Operator02 Expression02 Expression01List; + // 359 - ExpressionList: Operator01 Expression01 ExpressionList; Production { - lhs: 162, - production: &[ParseType::N(162), ParseType::N(163), ParseType::N(415)], + lhs: 194, + production: &[ParseType::N(194), ParseType::N(164), ParseType::N(418)], }, - // 356 - Expression01List: ; + // 360 - ExpressionList: ; Production { - lhs: 162, + lhs: 194, production: &[], }, - // 357 - Expression02: Expression03 Expression02List /* Vec */; - Production { - lhs: 163, - production: &[ParseType::N(164), ParseType::N(165)], - }, - // 358 - Expression02List: Operator03 Expression03 Expression02List; + // 361 - Expression01: Expression02 Expression01List /* Vec */; Production { lhs: 164, - production: &[ParseType::N(164), ParseType::N(165), ParseType::N(418)], + production: &[ParseType::N(165), ParseType::N(166)], }, - // 359 - Expression02List: ; + // 362 - Expression01List: Operator02 Expression02 Expression01List; Production { - lhs: 164, - production: &[], + lhs: 165, + production: &[ParseType::N(165), ParseType::N(166), ParseType::N(421)], }, - // 360 - Expression03: Expression04 Expression03List /* Vec */; + // 363 - Expression01List: ; Production { lhs: 165, - production: &[ParseType::N(166), ParseType::N(167)], + production: &[], }, - // 361 - Expression03List: Operator04 Expression04 Expression03List; + // 364 - Expression02: Expression03 Expression02List /* Vec */; Production { lhs: 166, - production: &[ParseType::N(166), ParseType::N(167), ParseType::N(421)], + production: &[ParseType::N(167), ParseType::N(168)], }, - // 362 - Expression03List: ; + // 365 - Expression02List: Operator03 Expression03 Expression02List; Production { - lhs: 166, - production: &[], + lhs: 167, + production: &[ParseType::N(167), ParseType::N(168), ParseType::N(424)], }, - // 363 - Expression04: Expression05 Expression04List /* Vec */; + // 366 - Expression02List: ; Production { lhs: 167, - production: &[ParseType::N(168), ParseType::N(169)], + production: &[], }, - // 364 - Expression04List: Operator05 Expression05 Expression04List; + // 367 - Expression03: Expression04 Expression03List /* Vec */; Production { lhs: 168, - production: &[ParseType::N(168), ParseType::N(169), ParseType::N(424)], + production: &[ParseType::N(169), ParseType::N(170)], }, - // 365 - Expression04List: ; + // 368 - Expression03List: Operator04 Expression04 Expression03List; Production { - lhs: 168, - production: &[], + lhs: 169, + production: &[ParseType::N(169), ParseType::N(170), ParseType::N(427)], }, - // 366 - Expression05: Expression06 Expression05List /* Vec */; + // 369 - Expression03List: ; Production { lhs: 169, - production: &[ParseType::N(170), ParseType::N(171)], + production: &[], }, - // 367 - Expression05List: Operator06 Expression06 Expression05List; + // 370 - Expression04: Expression05 Expression04List /* Vec */; Production { lhs: 170, - production: &[ParseType::N(170), ParseType::N(171), ParseType::N(427)], + production: &[ParseType::N(171), ParseType::N(172)], }, - // 368 - Expression05List: ; + // 371 - Expression04List: Operator05 Expression05 Expression04List; Production { - lhs: 170, - production: &[], + lhs: 171, + production: &[ParseType::N(171), ParseType::N(172), ParseType::N(430)], }, - // 369 - Expression06: Expression07 Expression06List /* Vec */; + // 372 - Expression04List: ; Production { lhs: 171, - production: &[ParseType::N(172), ParseType::N(173)], + production: &[], }, - // 370 - Expression06List: Operator07 Expression07 Expression06List; + // 373 - Expression05: Expression06 Expression05List /* Vec */; Production { lhs: 172, - production: &[ParseType::N(172), ParseType::N(173), ParseType::N(430)], + production: &[ParseType::N(173), ParseType::N(174)], }, - // 371 - Expression06List: ; + // 374 - Expression05List: Operator06 Expression06 Expression05List; Production { - lhs: 172, - production: &[], + lhs: 173, + production: &[ParseType::N(173), ParseType::N(174), ParseType::N(433)], }, - // 372 - Expression07: Expression08 Expression07List /* Vec */; + // 375 - Expression05List: ; Production { lhs: 173, - production: &[ParseType::N(174), ParseType::N(175)], + production: &[], }, - // 373 - Expression07List: Operator08 Expression08 Expression07List; + // 376 - Expression06: Expression07 Expression06List /* Vec */; Production { lhs: 174, - production: &[ParseType::N(174), ParseType::N(175), ParseType::N(433)], + production: &[ParseType::N(175), ParseType::N(176)], }, - // 374 - Expression07List: ; + // 377 - Expression06List: Operator07 Expression07 Expression06List; Production { - lhs: 174, - production: &[], + lhs: 175, + production: &[ParseType::N(175), ParseType::N(176), ParseType::N(436)], }, - // 375 - Expression08: Expression09 Expression08List /* Vec */; + // 378 - Expression06List: ; Production { lhs: 175, - production: &[ParseType::N(176), ParseType::N(177)], + production: &[], }, - // 376 - Expression08List: Operator09 Expression09 Expression08List; + // 379 - Expression07: Expression08 Expression07List /* Vec */; Production { lhs: 176, - production: &[ParseType::N(176), ParseType::N(177), ParseType::N(436)], + production: &[ParseType::N(177), ParseType::N(178)], }, - // 377 - Expression08List: ; + // 380 - Expression07List: Operator08 Expression08 Expression07List; Production { - lhs: 176, - production: &[], + lhs: 177, + production: &[ParseType::N(177), ParseType::N(178), ParseType::N(439)], }, - // 378 - Expression09: Expression10 Expression09List /* Vec */; + // 381 - Expression07List: ; Production { lhs: 177, - production: &[ParseType::N(178), ParseType::N(180)], + production: &[], }, - // 379 - Expression09List: Expression09ListGroup Expression10 Expression09List; + // 382 - Expression08: Expression09 Expression08List /* Vec */; Production { lhs: 178, - production: &[ParseType::N(178), ParseType::N(180), ParseType::N(179)], + production: &[ParseType::N(179), ParseType::N(180)], }, - // 380 - Expression09ListGroup: Operator10; + // 383 - Expression08List: Operator09 Expression09 Expression08List; Production { lhs: 179, - production: &[ParseType::N(439)], + production: &[ParseType::N(179), ParseType::N(180), ParseType::N(442)], }, - // 381 - Expression09ListGroup: Star; + // 384 - Expression08List: ; Production { lhs: 179, - production: &[ParseType::N(546)], - }, - // 382 - Expression09List: ; - Production { - lhs: 178, production: &[], }, - // 383 - Expression10: Expression11 Expression10List /* Vec */; + // 385 - Expression09: Expression10 Expression09List /* Vec */; Production { lhs: 180, - production: &[ParseType::N(181), ParseType::N(182)], + production: &[ParseType::N(181), ParseType::N(183)], }, - // 384 - Expression10List: Operator11 Expression11 Expression10List; + // 386 - Expression09List: Expression09ListGroup Expression10 Expression09List; Production { lhs: 181, - production: &[ParseType::N(181), ParseType::N(182), ParseType::N(442)], + production: &[ParseType::N(181), ParseType::N(183), ParseType::N(182)], }, - // 385 - Expression10List: ; + // 387 - Expression09ListGroup: Operator10; Production { - lhs: 181, - production: &[], + lhs: 182, + production: &[ParseType::N(445)], }, - // 386 - Expression11: Expression12 Expression11List /* Vec */; + // 388 - Expression09ListGroup: Star; Production { lhs: 182, - production: &[ParseType::N(183), ParseType::N(184)], + production: &[ParseType::N(555)], }, - // 387 - Expression11List: As ScopedIdentifier Expression11List; + // 389 - Expression09List: ; Production { - lhs: 183, - production: &[ParseType::N(183), ParseType::N(534), ParseType::N(31)], + lhs: 181, + production: &[], }, - // 388 - Expression11List: ; + // 390 - Expression10: Expression11 Expression10List /* Vec */; Production { lhs: 183, - production: &[], + production: &[ParseType::N(184), ParseType::N(185)], + }, + // 391 - Expression10List: Operator11 Expression11 Expression10List; + Production { + lhs: 184, + production: &[ParseType::N(184), ParseType::N(185), ParseType::N(448)], }, - // 389 - Expression12: Expression12List /* Vec */ Factor; + // 392 - Expression10List: ; Production { lhs: 184, - production: &[ParseType::N(198), ParseType::N(185)], + production: &[], }, - // 390 - Expression12List: Expression12ListGroup Expression12List; + // 393 - Expression11: Expression12 Expression11List /* Vec */; Production { lhs: 185, - production: &[ParseType::N(185), ParseType::N(186)], + production: &[ParseType::N(186), ParseType::N(187)], }, - // 391 - Expression12ListGroup: UnaryOperator; + // 394 - Expression11List: As ScopedIdentifier Expression11List; Production { lhs: 186, - production: &[ParseType::N(588)], + production: &[ParseType::N(186), ParseType::N(541), ParseType::N(31)], }, - // 392 - Expression12ListGroup: Operator09; + // 395 - Expression11List: ; Production { lhs: 186, - production: &[ParseType::N(436)], + production: &[], }, - // 393 - Expression12ListGroup: Operator05; + // 396 - Expression12: Expression12List /* Vec */ Factor; Production { - lhs: 186, - production: &[ParseType::N(424)], + lhs: 187, + production: &[ParseType::N(201), ParseType::N(188)], }, - // 394 - Expression12ListGroup: Operator03; + // 397 - Expression12List: Expression12ListGroup Expression12List; Production { - lhs: 186, - production: &[ParseType::N(418)], + lhs: 188, + production: &[ParseType::N(188), ParseType::N(189)], }, - // 395 - Expression12ListGroup: Operator04; + // 398 - Expression12ListGroup: UnaryOperator; Production { - lhs: 186, - production: &[ParseType::N(421)], + lhs: 189, + production: &[ParseType::N(598)], }, - // 396 - Expression12List: ; + // 399 - Expression12ListGroup: Operator09; Production { - lhs: 185, - production: &[], + lhs: 189, + production: &[ParseType::N(442)], }, - // 397 - Factor: Number; + // 400 - Expression12ListGroup: Operator05; Production { - lhs: 198, - production: &[ParseType::N(411)], + lhs: 189, + production: &[ParseType::N(430)], }, - // 398 - Factor: ExpressionIdentifier FactorOpt /* Option */; + // 401 - Expression12ListGroup: Operator03; Production { - lhs: 198, - production: &[ParseType::N(200), ParseType::N(187)], + lhs: 189, + production: &[ParseType::N(424)], }, - // 399 - Factor: LParen Expression RParen; + // 402 - Expression12ListGroup: Operator04; Production { - lhs: 198, - production: &[ParseType::N(495), ParseType::N(160), ParseType::N(349)], + lhs: 189, + production: &[ParseType::N(427)], }, - // 400 - Factor: LBrace ConcatenationList RBrace; + // 403 - Expression12List: ; Production { - lhs: 198, - production: &[ParseType::N(489), ParseType::N(100), ParseType::N(343)], + lhs: 188, + production: &[], }, - // 401 - Factor: QuoteLBrace ArrayLiteralList RBrace; + // 404 - Factor: Number; Production { - lhs: 198, - production: &[ParseType::N(489), ParseType::N(26), ParseType::N(483)], + lhs: 201, + production: &[ParseType::N(417)], }, - // 402 - Factor: IfExpression; + // 405 - Factor: ExpressionIdentifier FactorOpt /* Option */; Production { - lhs: 198, - production: &[ParseType::N(245)], + lhs: 201, + production: &[ParseType::N(203), ParseType::N(190)], }, - // 403 - Factor: CaseExpression; + // 406 - Factor: LParen Expression RParen; Production { - lhs: 198, - production: &[ParseType::N(63)], + lhs: 201, + production: &[ParseType::N(502), ParseType::N(163), ParseType::N(354)], }, - // 404 - Factor: StringLiteral; + // 407 - Factor: LBrace ConcatenationList RBrace; Production { - lhs: 198, - production: &[ParseType::N(556)], + lhs: 201, + production: &[ParseType::N(496), ParseType::N(103), ParseType::N(348)], }, - // 405 - Factor: FactorGroup; + // 408 - Factor: QuoteLBrace ArrayLiteralList RBrace; Production { - lhs: 198, - production: &[ParseType::N(199)], + lhs: 201, + production: &[ParseType::N(496), ParseType::N(26), ParseType::N(490)], }, - // 406 - FactorGroup: Msb; + // 409 - Factor: IfExpression; Production { - lhs: 199, - production: &[ParseType::N(408)], + lhs: 201, + production: &[ParseType::N(249)], }, - // 407 - FactorGroup: Lsb; + // 410 - Factor: CaseExpression; Production { - lhs: 199, - production: &[ParseType::N(365)], + lhs: 201, + production: &[ParseType::N(63)], }, - // 408 - Factor: InsideExpression; + // 411 - Factor: StringLiteral; Production { - lhs: 198, - production: &[ParseType::N(288)], + lhs: 201, + production: &[ParseType::N(565)], }, - // 409 - Factor: OutsideExpression; + // 412 - Factor: FactorGroup; Production { - lhs: 198, - production: &[ParseType::N(449)], + lhs: 201, + production: &[ParseType::N(202)], }, - // 410 - FactorOpt: FunctionCall; + // 413 - FactorGroup: Msb; Production { - lhs: 200, - production: &[ParseType::N(217)], + lhs: 202, + production: &[ParseType::N(414)], }, - // 411 - FactorOpt: ; + // 414 - FactorGroup: Lsb; Production { - lhs: 200, + lhs: 202, + production: &[ParseType::N(370)], + }, + // 415 - Factor: InsideExpression; + Production { + lhs: 201, + production: &[ParseType::N(292)], + }, + // 416 - Factor: OutsideExpression; + Production { + lhs: 201, + production: &[ParseType::N(455)], + }, + // 417 - FactorOpt: FunctionCall; + Production { + lhs: 203, + production: &[ParseType::N(220)], + }, + // 418 - FactorOpt: ; + Production { + lhs: 203, production: &[], }, - // 412 - FunctionCall: LParen FunctionCallOpt /* Option */ RParen; + // 419 - FunctionCall: LParen FunctionCallOpt /* Option */ RParen; Production { - lhs: 217, - production: &[ParseType::N(495), ParseType::N(218), ParseType::N(349)], + lhs: 220, + production: &[ParseType::N(502), ParseType::N(221), ParseType::N(354)], }, - // 413 - FunctionCallOpt: ArgumentList; + // 420 - FunctionCallOpt: ArgumentList; Production { - lhs: 218, + lhs: 221, production: &[ParseType::N(18)], }, - // 414 - FunctionCallOpt: ; + // 421 - FunctionCallOpt: ; Production { - lhs: 218, + lhs: 221, production: &[], }, - // 415 - ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */; + // 422 - ArgumentList: ArgumentItem ArgumentListList /* Vec */ ArgumentListOpt /* Option */; Production { lhs: 18, production: &[ParseType::N(20), ParseType::N(19), ParseType::N(17)], }, - // 416 - ArgumentListList: Comma ArgumentItem ArgumentListList; + // 423 - ArgumentListList: Comma ArgumentItem ArgumentListList; Production { lhs: 19, - production: &[ParseType::N(19), ParseType::N(17), ParseType::N(92)], + production: &[ParseType::N(19), ParseType::N(17), ParseType::N(95)], }, - // 417 - ArgumentListList: ; + // 424 - ArgumentListList: ; Production { lhs: 19, production: &[], }, - // 418 - ArgumentListOpt: Comma; + // 425 - ArgumentListOpt: Comma; Production { lhs: 20, - production: &[ParseType::N(92)], + production: &[ParseType::N(95)], }, - // 419 - ArgumentListOpt: ; + // 426 - ArgumentListOpt: ; Production { lhs: 20, production: &[], }, - // 420 - ArgumentItem: Expression; + // 427 - ArgumentItem: Expression; Production { lhs: 17, - production: &[ParseType::N(160)], + production: &[ParseType::N(163)], }, - // 421 - ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */; + // 428 - ConcatenationList: ConcatenationItem ConcatenationListList /* Vec */ ConcatenationListOpt /* Option */; Production { - lhs: 100, - production: &[ParseType::N(102), ParseType::N(101), ParseType::N(98)], + lhs: 103, + production: &[ParseType::N(105), ParseType::N(104), ParseType::N(101)], }, - // 422 - ConcatenationListList: Comma ConcatenationItem ConcatenationListList; + // 429 - ConcatenationListList: Comma ConcatenationItem ConcatenationListList; Production { - lhs: 101, - production: &[ParseType::N(101), ParseType::N(98), ParseType::N(92)], + lhs: 104, + production: &[ParseType::N(104), ParseType::N(101), ParseType::N(95)], }, - // 423 - ConcatenationListList: ; + // 430 - ConcatenationListList: ; Production { - lhs: 101, + lhs: 104, production: &[], }, - // 424 - ConcatenationListOpt: Comma; + // 431 - ConcatenationListOpt: Comma; Production { - lhs: 102, - production: &[ParseType::N(92)], + lhs: 105, + production: &[ParseType::N(95)], }, - // 425 - ConcatenationListOpt: ; + // 432 - ConcatenationListOpt: ; Production { - lhs: 102, + lhs: 105, production: &[], }, - // 426 - ConcatenationItem: Expression ConcatenationItemOpt /* Option */; + // 433 - ConcatenationItem: Expression ConcatenationItemOpt /* Option */; Production { - lhs: 98, - production: &[ParseType::N(99), ParseType::N(160)], + lhs: 101, + production: &[ParseType::N(102), ParseType::N(163)], }, - // 427 - ConcatenationItemOpt: Repeat Expression; + // 434 - ConcatenationItemOpt: Repeat Expression; Production { - lhs: 99, - production: &[ParseType::N(160), ParseType::N(509)], + lhs: 102, + production: &[ParseType::N(163), ParseType::N(516)], }, - // 428 - ConcatenationItemOpt: ; + // 435 - ConcatenationItemOpt: ; Production { - lhs: 99, + lhs: 102, production: &[], }, - // 429 - ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */; + // 436 - ArrayLiteralList: ArrayLiteralItem ArrayLiteralListList /* Vec */ ArrayLiteralListOpt /* Option */; Production { lhs: 26, production: &[ParseType::N(28), ParseType::N(27), ParseType::N(23)], }, - // 430 - ArrayLiteralListList: Comma ArrayLiteralItem ArrayLiteralListList; + // 437 - ArrayLiteralListList: Comma ArrayLiteralItem ArrayLiteralListList; Production { lhs: 27, - production: &[ParseType::N(27), ParseType::N(23), ParseType::N(92)], + production: &[ParseType::N(27), ParseType::N(23), ParseType::N(95)], }, - // 431 - ArrayLiteralListList: ; + // 438 - ArrayLiteralListList: ; Production { lhs: 27, production: &[], }, - // 432 - ArrayLiteralListOpt: Comma; + // 439 - ArrayLiteralListOpt: Comma; Production { lhs: 28, - production: &[ParseType::N(92)], + production: &[ParseType::N(95)], }, - // 433 - ArrayLiteralListOpt: ; + // 440 - ArrayLiteralListOpt: ; Production { lhs: 28, production: &[], }, - // 434 - ArrayLiteralItem: ArrayLiteralItemGroup; + // 441 - ArrayLiteralItem: ArrayLiteralItemGroup; Production { lhs: 23, production: &[ParseType::N(24)], }, - // 435 - ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */; + // 442 - ArrayLiteralItemGroup: Expression ArrayLiteralItemOpt /* Option */; Production { lhs: 24, - production: &[ParseType::N(25), ParseType::N(160)], + production: &[ParseType::N(25), ParseType::N(163)], }, - // 436 - ArrayLiteralItemGroup: Defaul Colon Expression; + // 443 - ArrayLiteralItemGroup: Defaul Colon Expression; Production { lhs: 24, - production: &[ParseType::N(160), ParseType::N(86), ParseType::N(103)], + production: &[ParseType::N(163), ParseType::N(86), ParseType::N(106)], }, - // 437 - ArrayLiteralItemOpt: Repeat Expression; + // 444 - ArrayLiteralItemOpt: Repeat Expression; Production { lhs: 25, - production: &[ParseType::N(160), ParseType::N(509)], + production: &[ParseType::N(163), ParseType::N(516)], }, - // 438 - ArrayLiteralItemOpt: ; + // 445 - ArrayLiteralItemOpt: ; Production { lhs: 25, production: &[], }, - // 439 - IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace; + // 446 - IfExpression: If Expression LBrace Expression RBrace IfExpressionList /* Vec */ Else LBrace Expression RBrace; Production { - lhs: 245, + lhs: 249, production: &[ - ParseType::N(489), - ParseType::N(160), - ParseType::N(343), - ParseType::N(124), - ParseType::N(246), - ParseType::N(489), - ParseType::N(160), - ParseType::N(343), - ParseType::N(160), - ParseType::N(244), + ParseType::N(496), + ParseType::N(163), + ParseType::N(348), + ParseType::N(127), + ParseType::N(250), + ParseType::N(496), + ParseType::N(163), + ParseType::N(348), + ParseType::N(163), + ParseType::N(248), ], }, - // 440 - IfExpressionList: Else If Expression LBrace Expression RBrace IfExpressionList; + // 447 - IfExpressionList: Else If Expression LBrace Expression RBrace IfExpressionList; Production { - lhs: 246, + lhs: 250, production: &[ - ParseType::N(246), - ParseType::N(489), - ParseType::N(160), - ParseType::N(343), - ParseType::N(160), - ParseType::N(244), - ParseType::N(124), + ParseType::N(250), + ParseType::N(496), + ParseType::N(163), + ParseType::N(348), + ParseType::N(163), + ParseType::N(248), + ParseType::N(127), ], }, - // 441 - IfExpressionList: ; + // 448 - IfExpressionList: ; Production { - lhs: 246, + lhs: 250, production: &[], }, - // 442 - CaseExpression: Case Expression LBrace Expression CaseExpressionList /* Vec */ Colon Expression Comma CaseExpressionList0 /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace; + // 449 - CaseExpression: Case Expression LBrace Expression CaseExpressionList /* Vec */ Colon Expression Comma CaseExpressionList0 /* Vec */ Defaul Colon Expression CaseExpressionOpt /* Option */ RBrace; Production { lhs: 63, production: &[ - ParseType::N(489), + ParseType::N(496), ParseType::N(67), - ParseType::N(160), + ParseType::N(163), ParseType::N(86), - ParseType::N(103), + ParseType::N(106), ParseType::N(65), - ParseType::N(92), - ParseType::N(160), + ParseType::N(95), + ParseType::N(163), ParseType::N(86), ParseType::N(64), - ParseType::N(160), - ParseType::N(343), - ParseType::N(160), + ParseType::N(163), + ParseType::N(348), + ParseType::N(163), ParseType::N(62), ], }, - // 443 - CaseExpressionList0: Expression CaseExpressionList0List /* Vec */ Colon Expression Comma CaseExpressionList0; + // 450 - CaseExpressionList0: Expression CaseExpressionList0List /* Vec */ Colon Expression Comma CaseExpressionList0; Production { lhs: 65, production: &[ ParseType::N(65), - ParseType::N(92), - ParseType::N(160), + ParseType::N(95), + ParseType::N(163), ParseType::N(86), ParseType::N(66), - ParseType::N(160), + ParseType::N(163), ], }, - // 444 - CaseExpressionList0List: Comma Expression CaseExpressionList0List; + // 451 - CaseExpressionList0List: Comma Expression CaseExpressionList0List; Production { lhs: 66, - production: &[ParseType::N(66), ParseType::N(160), ParseType::N(92)], + production: &[ParseType::N(66), ParseType::N(163), ParseType::N(95)], }, - // 445 - CaseExpressionList0List: ; + // 452 - CaseExpressionList0List: ; Production { lhs: 66, production: &[], }, - // 446 - CaseExpressionList0: ; + // 453 - CaseExpressionList0: ; Production { lhs: 65, production: &[], }, - // 447 - CaseExpressionList: Comma Expression CaseExpressionList; + // 454 - CaseExpressionList: Comma Expression CaseExpressionList; Production { lhs: 64, - production: &[ParseType::N(64), ParseType::N(160), ParseType::N(92)], + production: &[ParseType::N(64), ParseType::N(163), ParseType::N(95)], }, - // 448 - CaseExpressionList: ; + // 455 - CaseExpressionList: ; Production { lhs: 64, production: &[], }, - // 449 - CaseExpressionOpt: Comma; + // 456 - CaseExpressionOpt: Comma; Production { lhs: 67, - production: &[ParseType::N(92)], + production: &[ParseType::N(95)], }, - // 450 - CaseExpressionOpt: ; + // 457 - CaseExpressionOpt: ; Production { lhs: 67, production: &[], }, - // 451 - TypeExpression: ScalarType; + // 458 - TypeExpression: ScalarType; Production { - lhs: 578, - production: &[ParseType::N(531)], + lhs: 588, + production: &[ParseType::N(538)], }, - // 452 - TypeExpression: Type LParen Expression RParen; + // 459 - TypeExpression: Type LParen Expression RParen; Production { - lhs: 578, + lhs: 588, production: &[ - ParseType::N(495), - ParseType::N(160), - ParseType::N(349), - ParseType::N(576), + ParseType::N(502), + ParseType::N(163), + ParseType::N(354), + ParseType::N(586), ], }, - // 453 - InsideExpression: Inside Expression LBrace RangeList RBrace; + // 460 - InsideExpression: Inside Expression LBrace RangeList RBrace; Production { - lhs: 288, + lhs: 292, production: &[ - ParseType::N(489), - ParseType::N(500), - ParseType::N(343), - ParseType::N(160), - ParseType::N(287), + ParseType::N(496), + ParseType::N(507), + ParseType::N(348), + ParseType::N(163), + ParseType::N(291), ], }, - // 454 - OutsideExpression: Outside Expression LBrace RangeList RBrace; + // 461 - OutsideExpression: Outside Expression LBrace RangeList RBrace; Production { - lhs: 449, + lhs: 455, production: &[ - ParseType::N(489), - ParseType::N(500), - ParseType::N(343), - ParseType::N(160), - ParseType::N(448), + ParseType::N(496), + ParseType::N(507), + ParseType::N(348), + ParseType::N(163), + ParseType::N(454), ], }, - // 455 - RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */; + // 462 - RangeList: RangeItem RangeListList /* Vec */ RangeListOpt /* Option */; Production { - lhs: 500, - production: &[ParseType::N(502), ParseType::N(501), ParseType::N(499)], + lhs: 507, + production: &[ParseType::N(509), ParseType::N(508), ParseType::N(506)], }, - // 456 - RangeListList: Comma RangeItem RangeListList; + // 463 - RangeListList: Comma RangeItem RangeListList; Production { - lhs: 501, - production: &[ParseType::N(501), ParseType::N(499), ParseType::N(92)], + lhs: 508, + production: &[ParseType::N(508), ParseType::N(506), ParseType::N(95)], }, - // 457 - RangeListList: ; + // 464 - RangeListList: ; Production { - lhs: 501, + lhs: 508, production: &[], }, - // 458 - RangeListOpt: Comma; + // 465 - RangeListOpt: Comma; Production { - lhs: 502, - production: &[ParseType::N(92)], + lhs: 509, + production: &[ParseType::N(95)], }, - // 459 - RangeListOpt: ; + // 466 - RangeListOpt: ; Production { - lhs: 502, + lhs: 509, production: &[], }, - // 460 - RangeItem: Range; + // 467 - RangeItem: Range; Production { - lhs: 499, - production: &[ParseType::N(498)], + lhs: 506, + production: &[ParseType::N(505)], }, - // 461 - Select: LBracket Expression SelectOpt /* Option */ RBracket; + // 468 - Select: LBracket Expression SelectOpt /* Option */ RBracket; Production { - lhs: 537, + lhs: 546, production: &[ - ParseType::N(492), - ParseType::N(539), - ParseType::N(160), - ParseType::N(346), + ParseType::N(499), + ParseType::N(548), + ParseType::N(163), + ParseType::N(351), ], }, - // 462 - SelectOpt: SelectOperator Expression; + // 469 - SelectOpt: SelectOperator Expression; Production { - lhs: 539, - production: &[ParseType::N(160), ParseType::N(538)], + lhs: 548, + production: &[ParseType::N(163), ParseType::N(547)], }, - // 463 - SelectOpt: ; + // 470 - SelectOpt: ; Production { - lhs: 539, + lhs: 548, production: &[], }, - // 464 - SelectOperator: Colon; + // 471 - SelectOperator: Colon; Production { - lhs: 538, + lhs: 547, production: &[ParseType::N(86)], }, - // 465 - SelectOperator: PlusColon; + // 472 - SelectOperator: PlusColon; Production { - lhs: 538, - production: &[ParseType::N(466)], + lhs: 547, + production: &[ParseType::N(473)], }, - // 466 - SelectOperator: MinusColon; + // 473 - SelectOperator: MinusColon; Production { - lhs: 538, - production: &[ParseType::N(368)], + lhs: 547, + production: &[ParseType::N(373)], }, - // 467 - SelectOperator: Step; + // 474 - SelectOperator: Step; Production { - lhs: 538, - production: &[ParseType::N(552)], + lhs: 547, + production: &[ParseType::N(561)], }, - // 468 - Width: LAngle Expression WidthList /* Vec */ RAngle; + // 475 - Width: LAngle Expression WidthList /* Vec */ RAngle; Production { - lhs: 603, + lhs: 613, production: &[ - ParseType::N(486), - ParseType::N(604), - ParseType::N(160), - ParseType::N(340), + ParseType::N(493), + ParseType::N(614), + ParseType::N(163), + ParseType::N(345), ], }, - // 469 - WidthList: Comma Expression WidthList; + // 476 - WidthList: Comma Expression WidthList; Production { - lhs: 604, - production: &[ParseType::N(604), ParseType::N(160), ParseType::N(92)], + lhs: 614, + production: &[ParseType::N(614), ParseType::N(163), ParseType::N(95)], }, - // 470 - WidthList: ; + // 477 - WidthList: ; Production { - lhs: 604, + lhs: 614, production: &[], }, - // 471 - Array: LBracket Expression ArrayList /* Vec */ RBracket; + // 478 - Array: LBracket Expression ArrayList /* Vec */ RBracket; Production { lhs: 21, production: &[ - ParseType::N(492), + ParseType::N(499), ParseType::N(22), - ParseType::N(160), - ParseType::N(346), + ParseType::N(163), + ParseType::N(351), ], }, - // 472 - ArrayList: Comma Expression ArrayList; + // 479 - ArrayList: Comma Expression ArrayList; Production { lhs: 22, - production: &[ParseType::N(22), ParseType::N(160), ParseType::N(92)], + production: &[ParseType::N(22), ParseType::N(163), ParseType::N(95)], }, - // 473 - ArrayList: ; + // 480 - ArrayList: ; Production { lhs: 22, production: &[], }, - // 474 - Range: Expression RangeOpt /* Option */; + // 481 - Range: Expression RangeOpt /* Option */; Production { - lhs: 498, - production: &[ParseType::N(504), ParseType::N(160)], + lhs: 505, + production: &[ParseType::N(511), ParseType::N(163)], }, - // 475 - RangeOpt: RangeOperator Expression; + // 482 - RangeOpt: RangeOperator Expression; Production { - lhs: 504, - production: &[ParseType::N(160), ParseType::N(503)], + lhs: 511, + production: &[ParseType::N(163), ParseType::N(510)], }, - // 476 - RangeOpt: ; + // 483 - RangeOpt: ; Production { - lhs: 504, + lhs: 511, production: &[], }, - // 477 - RangeOperator: DotDot; + // 484 - RangeOperator: DotDot; Production { - lhs: 503, - production: &[ParseType::N(116)], + lhs: 510, + production: &[ParseType::N(119)], }, - // 478 - RangeOperator: DotDotEqu; + // 485 - RangeOperator: DotDotEqu; Production { - lhs: 503, - production: &[ParseType::N(117)], + lhs: 510, + production: &[ParseType::N(120)], }, - // 479 - FixedType: U32; + // 486 - FixedType: U32; Production { - lhs: 209, - production: &[ParseType::N(582)], + lhs: 212, + production: &[ParseType::N(592)], }, - // 480 - FixedType: U64; + // 487 - FixedType: U64; Production { - lhs: 209, - production: &[ParseType::N(585)], + lhs: 212, + production: &[ParseType::N(595)], }, - // 481 - FixedType: I32; + // 488 - FixedType: I32; Production { - lhs: 209, - production: &[ParseType::N(233)], + lhs: 212, + production: &[ParseType::N(237)], }, - // 482 - FixedType: I64; + // 489 - FixedType: I64; Production { - lhs: 209, - production: &[ParseType::N(236)], + lhs: 212, + production: &[ParseType::N(240)], }, - // 483 - FixedType: F32; + // 490 - FixedType: F32; Production { - lhs: 209, - production: &[ParseType::N(192)], + lhs: 212, + production: &[ParseType::N(195)], }, - // 484 - FixedType: F64; + // 491 - FixedType: F64; Production { - lhs: 209, - production: &[ParseType::N(195)], + lhs: 212, + production: &[ParseType::N(198)], }, - // 485 - FixedType: Strin; + // 492 - FixedType: Strin; Production { - lhs: 209, - production: &[ParseType::N(555)], + lhs: 212, + production: &[ParseType::N(564)], }, - // 486 - VariableType: VariableTypeGroup VariableTypeOpt /* Option */; + // 493 - VariableType: VariableTypeGroup VariableTypeOpt /* Option */; Production { - lhs: 598, - production: &[ParseType::N(600), ParseType::N(599)], + lhs: 608, + production: &[ParseType::N(610), ParseType::N(609)], }, - // 487 - VariableTypeGroup: Clock; + // 494 - VariableTypeGroup: Clock; Production { - lhs: 599, + lhs: 609, production: &[ParseType::N(77)], }, - // 488 - VariableTypeGroup: ClockPosedge; + // 495 - VariableTypeGroup: ClockPosedge; Production { - lhs: 599, + lhs: 609, production: &[ParseType::N(81)], }, - // 489 - VariableTypeGroup: ClockNegedge; + // 496 - VariableTypeGroup: ClockNegedge; Production { - lhs: 599, + lhs: 609, production: &[ParseType::N(78)], }, - // 490 - VariableTypeGroup: Reset; + // 497 - VariableTypeGroup: Reset; Production { - lhs: 599, - production: &[ParseType::N(512)], + lhs: 609, + production: &[ParseType::N(519)], }, - // 491 - VariableTypeGroup: ResetAsyncHigh; + // 498 - VariableTypeGroup: ResetAsyncHigh; Production { - lhs: 599, - production: &[ParseType::N(513)], + lhs: 609, + production: &[ParseType::N(520)], }, - // 492 - VariableTypeGroup: ResetAsyncLow; + // 499 - VariableTypeGroup: ResetAsyncLow; Production { - lhs: 599, - production: &[ParseType::N(516)], + lhs: 609, + production: &[ParseType::N(523)], }, - // 493 - VariableTypeGroup: ResetSyncHigh; + // 500 - VariableTypeGroup: ResetSyncHigh; Production { - lhs: 599, - production: &[ParseType::N(519)], + lhs: 609, + production: &[ParseType::N(526)], }, - // 494 - VariableTypeGroup: ResetSyncLow; + // 501 - VariableTypeGroup: ResetSyncLow; Production { - lhs: 599, - production: &[ParseType::N(522)], + lhs: 609, + production: &[ParseType::N(529)], }, - // 495 - VariableTypeGroup: Logic; + // 502 - VariableTypeGroup: Logic; Production { - lhs: 599, - production: &[ParseType::N(362)], + lhs: 609, + production: &[ParseType::N(367)], }, - // 496 - VariableTypeGroup: Bit; + // 503 - VariableTypeGroup: Bit; Production { - lhs: 599, + lhs: 609, production: &[ParseType::N(55)], }, - // 497 - VariableTypeGroup: ScopedIdentifier; + // 504 - VariableTypeGroup: ScopedIdentifier; Production { - lhs: 599, - production: &[ParseType::N(534)], + lhs: 609, + production: &[ParseType::N(541)], }, - // 498 - VariableTypeOpt: Width; + // 505 - VariableTypeOpt: Width; Production { - lhs: 600, - production: &[ParseType::N(603)], + lhs: 610, + production: &[ParseType::N(613)], }, - // 499 - VariableTypeOpt: ; + // 506 - VariableTypeOpt: ; Production { - lhs: 600, + lhs: 610, production: &[], }, - // 500 - TypeModifier: Tri; + // 507 - TypeModifier: Tri; Production { - lhs: 579, - production: &[ParseType::N(573)], + lhs: 589, + production: &[ParseType::N(583)], }, - // 501 - TypeModifier: Signed; + // 508 - TypeModifier: Signed; Production { - lhs: 579, - production: &[ParseType::N(543)], + lhs: 589, + production: &[ParseType::N(552)], }, - // 502 - ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup; + // 509 - ScalarType: ScalarTypeList /* Vec */ ScalarTypeGroup; Production { - lhs: 531, - production: &[ParseType::N(532), ParseType::N(533)], + lhs: 538, + production: &[ParseType::N(539), ParseType::N(540)], }, - // 503 - ScalarTypeGroup: VariableType; + // 510 - ScalarTypeGroup: VariableType; Production { - lhs: 532, - production: &[ParseType::N(598)], + lhs: 539, + production: &[ParseType::N(608)], }, - // 504 - ScalarTypeGroup: FixedType; + // 511 - ScalarTypeGroup: FixedType; Production { - lhs: 532, - production: &[ParseType::N(209)], + lhs: 539, + production: &[ParseType::N(212)], }, - // 505 - ScalarTypeList: TypeModifier ScalarTypeList; + // 512 - ScalarTypeList: TypeModifier ScalarTypeList; Production { - lhs: 533, - production: &[ParseType::N(533), ParseType::N(579)], + lhs: 540, + production: &[ParseType::N(540), ParseType::N(589)], }, - // 506 - ScalarTypeList: ; + // 513 - ScalarTypeList: ; Production { - lhs: 533, + lhs: 540, production: &[], }, - // 507 - ArrayType: ScalarType ArrayTypeOpt /* Option */; + // 514 - ArrayType: ScalarType ArrayTypeOpt /* Option */; Production { lhs: 29, - production: &[ParseType::N(30), ParseType::N(531)], + production: &[ParseType::N(30), ParseType::N(538)], }, - // 508 - ArrayTypeOpt: Array; + // 515 - ArrayTypeOpt: Array; Production { lhs: 30, production: &[ParseType::N(21)], }, - // 509 - ArrayTypeOpt: ; + // 516 - ArrayTypeOpt: ; Production { lhs: 30, production: &[], }, - // 510 - Statement: LetStatement; + // 517 - Statement: LetStatement; Production { - lhs: 551, - production: &[ParseType::N(354)], + lhs: 560, + production: &[ParseType::N(359)], }, - // 511 - Statement: IdentifierStatement; + // 518 - Statement: IdentifierStatement; Production { - lhs: 551, - production: &[ParseType::N(240)], + lhs: 560, + production: &[ParseType::N(244)], }, - // 512 - Statement: IfStatement; + // 519 - Statement: IfStatement; Production { - lhs: 551, - production: &[ParseType::N(256)], + lhs: 560, + production: &[ParseType::N(260)], }, - // 513 - Statement: IfResetStatement; + // 520 - Statement: IfResetStatement; Production { - lhs: 551, - production: &[ParseType::N(248)], + lhs: 560, + production: &[ParseType::N(252)], }, - // 514 - Statement: ReturnStatement; + // 521 - Statement: ReturnStatement; Production { - lhs: 551, - production: &[ParseType::N(528)], + lhs: 560, + production: &[ParseType::N(535)], }, - // 515 - Statement: BreakStatement; + // 522 - Statement: BreakStatement; Production { - lhs: 551, + lhs: 560, production: &[ParseType::N(59)], }, - // 516 - Statement: ForStatement; + // 523 - Statement: ForStatement; Production { - lhs: 551, - production: &[ParseType::N(211)], + lhs: 560, + production: &[ParseType::N(214)], }, - // 517 - Statement: CaseStatement; + // 524 - Statement: CaseStatement; Production { - lhs: 551, + lhs: 560, production: &[ParseType::N(73)], }, - // 518 - LetStatement: Let Identifier Colon ArrayType Equ Expression Semicolon; + // 525 - LetStatement: Let Identifier Colon ArrayType Equ Expression Semicolon; Production { - lhs: 354, + lhs: 359, production: &[ - ParseType::N(540), - ParseType::N(160), - ParseType::N(148), + ParseType::N(549), + ParseType::N(163), + ParseType::N(151), ParseType::N(29), ParseType::N(86), - ParseType::N(239), - ParseType::N(352), + ParseType::N(243), + ParseType::N(357), ], }, - // 519 - IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon; + // 526 - IdentifierStatement: ExpressionIdentifier IdentifierStatementGroup Semicolon; Production { - lhs: 240, - production: &[ParseType::N(540), ParseType::N(241), ParseType::N(187)], + lhs: 244, + production: &[ParseType::N(549), ParseType::N(245), ParseType::N(190)], }, - // 520 - IdentifierStatementGroup: FunctionCall; + // 527 - IdentifierStatementGroup: FunctionCall; Production { - lhs: 241, - production: &[ParseType::N(217)], + lhs: 245, + production: &[ParseType::N(220)], }, - // 521 - IdentifierStatementGroup: Assignment; + // 528 - IdentifierStatementGroup: Assignment; Production { - lhs: 241, + lhs: 245, production: &[ParseType::N(38)], }, - // 522 - Assignment: AssignmentGroup Expression; + // 529 - Assignment: AssignmentGroup Expression; Production { lhs: 38, - production: &[ParseType::N(160), ParseType::N(39)], + production: &[ParseType::N(163), ParseType::N(39)], }, - // 523 - AssignmentGroup: Equ; + // 530 - AssignmentGroup: Equ; Production { lhs: 39, - production: &[ParseType::N(148)], + production: &[ParseType::N(151)], }, - // 524 - AssignmentGroup: AssignmentOperator; + // 531 - AssignmentGroup: AssignmentOperator; Production { lhs: 39, production: &[ParseType::N(40)], }, - // 525 - IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */; + // 532 - IfStatement: If Expression LBrace IfStatementList /* Vec */ RBrace IfStatementList0 /* Vec */ IfStatementOpt /* Option */; Production { - lhs: 256, + lhs: 260, production: &[ - ParseType::N(260), - ParseType::N(258), - ParseType::N(489), - ParseType::N(257), - ParseType::N(343), - ParseType::N(160), - ParseType::N(244), + ParseType::N(264), + ParseType::N(262), + ParseType::N(496), + ParseType::N(261), + ParseType::N(348), + ParseType::N(163), + ParseType::N(248), ], }, - // 526 - IfStatementList0: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0; + // 533 - IfStatementList0: Else If Expression LBrace IfStatementList0List /* Vec */ RBrace IfStatementList0; Production { - lhs: 258, + lhs: 262, production: &[ - ParseType::N(258), - ParseType::N(489), - ParseType::N(259), - ParseType::N(343), - ParseType::N(160), - ParseType::N(244), - ParseType::N(124), + ParseType::N(262), + ParseType::N(496), + ParseType::N(263), + ParseType::N(348), + ParseType::N(163), + ParseType::N(248), + ParseType::N(127), ], }, - // 527 - IfStatementList0List: Statement IfStatementList0List; + // 534 - IfStatementList0List: Statement IfStatementList0List; Production { - lhs: 259, - production: &[ParseType::N(259), ParseType::N(551)], + lhs: 263, + production: &[ParseType::N(263), ParseType::N(560)], }, - // 528 - IfStatementList0List: ; + // 535 - IfStatementList0List: ; Production { - lhs: 259, + lhs: 263, production: &[], }, - // 529 - IfStatementList0: ; + // 536 - IfStatementList0: ; Production { - lhs: 258, + lhs: 262, production: &[], }, - // 530 - IfStatementList: Statement IfStatementList; + // 537 - IfStatementList: Statement IfStatementList; Production { - lhs: 257, - production: &[ParseType::N(257), ParseType::N(551)], + lhs: 261, + production: &[ParseType::N(261), ParseType::N(560)], }, - // 531 - IfStatementList: ; + // 538 - IfStatementList: ; Production { - lhs: 257, + lhs: 261, production: &[], }, - // 532 - IfStatementOpt: Else LBrace IfStatementOptList /* Vec */ RBrace; + // 539 - IfStatementOpt: Else LBrace IfStatementOptList /* Vec */ RBrace; Production { - lhs: 260, + lhs: 264, production: &[ - ParseType::N(489), - ParseType::N(261), - ParseType::N(343), - ParseType::N(124), + ParseType::N(496), + ParseType::N(265), + ParseType::N(348), + ParseType::N(127), ], }, - // 533 - IfStatementOptList: Statement IfStatementOptList; + // 540 - IfStatementOptList: Statement IfStatementOptList; Production { - lhs: 261, - production: &[ParseType::N(261), ParseType::N(551)], + lhs: 265, + production: &[ParseType::N(265), ParseType::N(560)], }, - // 534 - IfStatementOptList: ; + // 541 - IfStatementOptList: ; Production { - lhs: 261, + lhs: 265, production: &[], }, - // 535 - IfStatementOpt: ; + // 542 - IfStatementOpt: ; Production { - lhs: 260, + lhs: 264, production: &[], }, - // 536 - IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */; + // 543 - IfResetStatement: IfReset LBrace IfResetStatementList /* Vec */ RBrace IfResetStatementList0 /* Vec */ IfResetStatementOpt /* Option */; Production { - lhs: 248, + lhs: 252, production: &[ - ParseType::N(252), - ParseType::N(250), - ParseType::N(489), - ParseType::N(249), - ParseType::N(343), - ParseType::N(247), + ParseType::N(256), + ParseType::N(254), + ParseType::N(496), + ParseType::N(253), + ParseType::N(348), + ParseType::N(251), ], }, - // 537 - IfResetStatementList0: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0; + // 544 - IfResetStatementList0: Else If Expression LBrace IfResetStatementList0List /* Vec */ RBrace IfResetStatementList0; Production { - lhs: 250, + lhs: 254, production: &[ - ParseType::N(250), - ParseType::N(489), - ParseType::N(251), - ParseType::N(343), - ParseType::N(160), - ParseType::N(244), - ParseType::N(124), + ParseType::N(254), + ParseType::N(496), + ParseType::N(255), + ParseType::N(348), + ParseType::N(163), + ParseType::N(248), + ParseType::N(127), ], }, - // 538 - IfResetStatementList0List: Statement IfResetStatementList0List; + // 545 - IfResetStatementList0List: Statement IfResetStatementList0List; Production { - lhs: 251, - production: &[ParseType::N(251), ParseType::N(551)], + lhs: 255, + production: &[ParseType::N(255), ParseType::N(560)], }, - // 539 - IfResetStatementList0List: ; + // 546 - IfResetStatementList0List: ; Production { - lhs: 251, + lhs: 255, production: &[], }, - // 540 - IfResetStatementList0: ; + // 547 - IfResetStatementList0: ; Production { - lhs: 250, + lhs: 254, production: &[], }, - // 541 - IfResetStatementList: Statement IfResetStatementList; + // 548 - IfResetStatementList: Statement IfResetStatementList; Production { - lhs: 249, - production: &[ParseType::N(249), ParseType::N(551)], + lhs: 253, + production: &[ParseType::N(253), ParseType::N(560)], }, - // 542 - IfResetStatementList: ; + // 549 - IfResetStatementList: ; Production { - lhs: 249, + lhs: 253, production: &[], }, - // 543 - IfResetStatementOpt: Else LBrace IfResetStatementOptList /* Vec */ RBrace; + // 550 - IfResetStatementOpt: Else LBrace IfResetStatementOptList /* Vec */ RBrace; Production { - lhs: 252, + lhs: 256, production: &[ - ParseType::N(489), - ParseType::N(253), - ParseType::N(343), - ParseType::N(124), + ParseType::N(496), + ParseType::N(257), + ParseType::N(348), + ParseType::N(127), ], }, - // 544 - IfResetStatementOptList: Statement IfResetStatementOptList; + // 551 - IfResetStatementOptList: Statement IfResetStatementOptList; Production { - lhs: 253, - production: &[ParseType::N(253), ParseType::N(551)], + lhs: 257, + production: &[ParseType::N(257), ParseType::N(560)], }, - // 545 - IfResetStatementOptList: ; + // 552 - IfResetStatementOptList: ; Production { - lhs: 253, + lhs: 257, production: &[], }, - // 546 - IfResetStatementOpt: ; + // 553 - IfResetStatementOpt: ; Production { - lhs: 252, + lhs: 256, production: &[], }, - // 547 - ReturnStatement: Return Expression Semicolon; + // 554 - ReturnStatement: Return Expression Semicolon; Production { - lhs: 528, - production: &[ParseType::N(540), ParseType::N(160), ParseType::N(527)], + lhs: 535, + production: &[ParseType::N(549), ParseType::N(163), ParseType::N(534)], }, - // 548 - BreakStatement: Break Semicolon; + // 555 - BreakStatement: Break Semicolon; Production { lhs: 59, - production: &[ParseType::N(540), ParseType::N(58)], + production: &[ParseType::N(549), ParseType::N(58)], }, - // 549 - ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace; + // 556 - ForStatement: For Identifier Colon ScalarType In Range ForStatementOpt /* Option */ LBrace ForStatementList /* Vec */ RBrace; Production { - lhs: 211, + lhs: 214, production: &[ - ParseType::N(489), - ParseType::N(212), - ParseType::N(343), - ParseType::N(213), - ParseType::N(498), - ParseType::N(269), - ParseType::N(531), + ParseType::N(496), + ParseType::N(215), + ParseType::N(348), + ParseType::N(216), + ParseType::N(505), + ParseType::N(273), + ParseType::N(538), ParseType::N(86), - ParseType::N(239), - ParseType::N(210), + ParseType::N(243), + ParseType::N(213), ], }, - // 550 - ForStatementList: Statement ForStatementList; + // 557 - ForStatementList: Statement ForStatementList; Production { - lhs: 212, - production: &[ParseType::N(212), ParseType::N(551)], + lhs: 215, + production: &[ParseType::N(215), ParseType::N(560)], }, - // 551 - ForStatementList: ; + // 558 - ForStatementList: ; Production { - lhs: 212, + lhs: 215, production: &[], }, - // 552 - ForStatementOpt: Step AssignmentOperator Expression; + // 559 - ForStatementOpt: Step AssignmentOperator Expression; Production { - lhs: 213, - production: &[ParseType::N(160), ParseType::N(40), ParseType::N(552)], + lhs: 216, + production: &[ParseType::N(163), ParseType::N(40), ParseType::N(561)], }, - // 553 - ForStatementOpt: ; + // 560 - ForStatementOpt: ; Production { - lhs: 213, + lhs: 216, production: &[], }, - // 554 - CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace; + // 561 - CaseStatement: Case Expression LBrace CaseStatementList /* Vec */ RBrace; Production { lhs: 73, production: &[ - ParseType::N(489), + ParseType::N(496), ParseType::N(74), - ParseType::N(343), - ParseType::N(160), + ParseType::N(348), + ParseType::N(163), ParseType::N(62), ], }, - // 555 - CaseStatementList: CaseItem CaseStatementList; + // 562 - CaseStatementList: CaseItem CaseStatementList; Production { lhs: 74, production: &[ParseType::N(74), ParseType::N(68)], }, - // 556 - CaseStatementList: ; + // 563 - CaseStatementList: ; Production { lhs: 74, production: &[], }, - // 557 - CaseItem: CaseItemGroup Colon CaseItemGroup0; + // 564 - CaseItem: CaseItemGroup Colon CaseItemGroup0; Production { lhs: 68, production: &[ParseType::N(70), ParseType::N(86), ParseType::N(69)], }, - // 558 - CaseItemGroup0: Statement; + // 565 - CaseItemGroup0: Statement; Production { lhs: 70, - production: &[ParseType::N(551)], + production: &[ParseType::N(560)], }, - // 559 - CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace; + // 566 - CaseItemGroup0: LBrace CaseItemGroup0List /* Vec */ RBrace; Production { lhs: 70, - production: &[ParseType::N(489), ParseType::N(71), ParseType::N(343)], + production: &[ParseType::N(496), ParseType::N(71), ParseType::N(348)], }, - // 560 - CaseItemGroup0List: Statement CaseItemGroup0List; + // 567 - CaseItemGroup0List: Statement CaseItemGroup0List; Production { lhs: 71, - production: &[ParseType::N(71), ParseType::N(551)], + production: &[ParseType::N(71), ParseType::N(560)], }, - // 561 - CaseItemGroup0List: ; + // 568 - CaseItemGroup0List: ; Production { lhs: 71, production: &[], }, - // 562 - CaseItemGroup: Expression CaseItemGroupList /* Vec */; + // 569 - CaseItemGroup: Expression CaseItemGroupList /* Vec */; Production { lhs: 69, - production: &[ParseType::N(72), ParseType::N(160)], + production: &[ParseType::N(72), ParseType::N(163)], }, - // 563 - CaseItemGroupList: Comma Expression CaseItemGroupList; + // 570 - CaseItemGroupList: Comma Expression CaseItemGroupList; Production { lhs: 72, - production: &[ParseType::N(72), ParseType::N(160), ParseType::N(92)], + production: &[ParseType::N(72), ParseType::N(163), ParseType::N(95)], }, - // 564 - CaseItemGroupList: ; + // 571 - CaseItemGroupList: ; Production { lhs: 72, production: &[], }, - // 565 - CaseItemGroup: Defaul; + // 572 - CaseItemGroup: Defaul; Production { lhs: 69, - production: &[ParseType::N(103)], + production: &[ParseType::N(106)], }, - // 566 - Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket; + // 573 - Attribute: Hash LBracket Identifier AttributeOpt /* Option */ RBracket; Production { lhs: 43, production: &[ - ParseType::N(492), + ParseType::N(499), ParseType::N(48), - ParseType::N(239), - ParseType::N(346), - ParseType::N(226), + ParseType::N(243), + ParseType::N(351), + ParseType::N(230), ], }, - // 567 - AttributeOpt: LParen AttributeList RParen; + // 574 - AttributeOpt: LParen AttributeList RParen; Production { lhs: 48, - production: &[ParseType::N(495), ParseType::N(45), ParseType::N(349)], + production: &[ParseType::N(502), ParseType::N(45), ParseType::N(354)], }, - // 568 - AttributeOpt: ; + // 575 - AttributeOpt: ; Production { lhs: 48, production: &[], }, - // 569 - AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */; + // 576 - AttributeList: AttributeItem AttributeListList /* Vec */ AttributeListOpt /* Option */; Production { lhs: 45, production: &[ParseType::N(47), ParseType::N(46), ParseType::N(44)], }, - // 570 - AttributeListList: Comma AttributeItem AttributeListList; + // 577 - AttributeListList: Comma AttributeItem AttributeListList; Production { lhs: 46, - production: &[ParseType::N(46), ParseType::N(44), ParseType::N(92)], + production: &[ParseType::N(46), ParseType::N(44), ParseType::N(95)], }, - // 571 - AttributeListList: ; + // 578 - AttributeListList: ; Production { lhs: 46, production: &[], }, - // 572 - AttributeListOpt: Comma; + // 579 - AttributeListOpt: Comma; Production { lhs: 47, - production: &[ParseType::N(92)], + production: &[ParseType::N(95)], }, - // 573 - AttributeListOpt: ; + // 580 - AttributeListOpt: ; Production { lhs: 47, production: &[], }, - // 574 - AttributeItem: Identifier; + // 581 - AttributeItem: Identifier; Production { lhs: 44, - production: &[ParseType::N(239)], + production: &[ParseType::N(243)], }, - // 575 - AttributeItem: StringLiteral; + // 582 - AttributeItem: StringLiteral; Production { lhs: 44, - production: &[ParseType::N(556)], + production: &[ParseType::N(565)], }, - // 576 - LetDeclaration: Let Identifier Colon ArrayType Equ Expression Semicolon; + // 583 - LetDeclaration: Let Identifier Colon ArrayType Equ Expression Semicolon; Production { - lhs: 353, + lhs: 358, production: &[ - ParseType::N(540), - ParseType::N(160), - ParseType::N(148), + ParseType::N(549), + ParseType::N(163), + ParseType::N(151), ParseType::N(29), ParseType::N(86), - ParseType::N(239), - ParseType::N(352), + ParseType::N(243), + ParseType::N(357), ], }, - // 577 - VarDeclaration: Var Identifier Colon ArrayType Semicolon; + // 584 - VarDeclaration: Var Identifier Colon ArrayType Semicolon; Production { - lhs: 595, + lhs: 605, production: &[ - ParseType::N(540), + ParseType::N(549), ParseType::N(29), ParseType::N(86), - ParseType::N(239), - ParseType::N(594), + ParseType::N(243), + ParseType::N(604), ], }, - // 578 - LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon; + // 585 - LocalDeclaration: Local Identifier Colon LocalDeclarationGroup Semicolon; Production { - lhs: 358, + lhs: 363, production: &[ - ParseType::N(540), - ParseType::N(359), + ParseType::N(549), + ParseType::N(364), ParseType::N(86), - ParseType::N(239), - ParseType::N(357), + ParseType::N(243), + ParseType::N(362), ], }, - // 579 - LocalDeclarationGroup: ArrayType Equ Expression; + // 586 - LocalDeclarationGroup: ArrayType Equ Expression; Production { - lhs: 359, - production: &[ParseType::N(160), ParseType::N(148), ParseType::N(29)], + lhs: 364, + production: &[ParseType::N(163), ParseType::N(151), ParseType::N(29)], }, - // 580 - LocalDeclarationGroup: Type Equ TypeExpression; + // 587 - LocalDeclarationGroup: Type Equ TypeExpression; Production { - lhs: 359, - production: &[ParseType::N(578), ParseType::N(148), ParseType::N(576)], + lhs: 364, + production: &[ParseType::N(588), ParseType::N(151), ParseType::N(586)], }, - // 581 - TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon; + // 588 - TypeDefDeclaration: Type Identifier Equ ArrayType Semicolon; Production { - lhs: 577, + lhs: 587, production: &[ - ParseType::N(540), + ParseType::N(549), ParseType::N(29), - ParseType::N(148), - ParseType::N(239), - ParseType::N(576), + ParseType::N(151), + ParseType::N(243), + ParseType::N(586), ], }, - // 582 - AlwaysFfDeclaration: AlwaysFf LParen AlwaysFfClock AlwaysFfDeclarationOpt /* Option */ RParen LBrace AlwaysFfDeclarationList /* Vec */ RBrace; + // 589 - AlwaysFfDeclaration: AlwaysFf LParen AlwaysFfClock AlwaysFfDeclarationOpt /* Option */ RParen LBrace AlwaysFfDeclarationList /* Vec */ RBrace; Production { lhs: 10, production: &[ - ParseType::N(489), + ParseType::N(496), ParseType::N(11), - ParseType::N(343), - ParseType::N(495), + ParseType::N(348), + ParseType::N(502), ParseType::N(12), ParseType::N(9), - ParseType::N(349), + ParseType::N(354), ParseType::N(8), ], }, - // 583 - AlwaysFfDeclarationList: Statement AlwaysFfDeclarationList; + // 590 - AlwaysFfDeclarationList: Statement AlwaysFfDeclarationList; Production { lhs: 11, - production: &[ParseType::N(11), ParseType::N(551)], + production: &[ParseType::N(11), ParseType::N(560)], }, - // 584 - AlwaysFfDeclarationList: ; + // 591 - AlwaysFfDeclarationList: ; Production { lhs: 11, production: &[], }, - // 585 - AlwaysFfDeclarationOpt: Comma AlwaysFfReset; + // 592 - AlwaysFfDeclarationOpt: Comma AlwaysFfReset; Production { lhs: 12, - production: &[ParseType::N(13), ParseType::N(92)], + production: &[ParseType::N(13), ParseType::N(95)], }, - // 586 - AlwaysFfDeclarationOpt: ; + // 593 - AlwaysFfDeclarationOpt: ; Production { lhs: 12, production: &[], }, - // 587 - AlwaysFfClock: HierarchicalIdentifier; + // 594 - AlwaysFfClock: HierarchicalIdentifier; Production { lhs: 9, - production: &[ParseType::N(229)], + production: &[ParseType::N(233)], }, - // 588 - AlwaysFfReset: HierarchicalIdentifier; + // 595 - AlwaysFfReset: HierarchicalIdentifier; Production { lhs: 13, - production: &[ParseType::N(229)], + production: &[ParseType::N(233)], }, - // 589 - AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace; + // 596 - AlwaysCombDeclaration: AlwaysComb LBrace AlwaysCombDeclarationList /* Vec */ RBrace; Production { lhs: 4, production: &[ - ParseType::N(489), + ParseType::N(496), ParseType::N(5), - ParseType::N(343), + ParseType::N(348), ParseType::N(3), ], }, - // 590 - AlwaysCombDeclarationList: Statement AlwaysCombDeclarationList; + // 597 - AlwaysCombDeclarationList: Statement AlwaysCombDeclarationList; Production { lhs: 5, - production: &[ParseType::N(5), ParseType::N(551)], + production: &[ParseType::N(5), ParseType::N(560)], }, - // 591 - AlwaysCombDeclarationList: ; + // 598 - AlwaysCombDeclarationList: ; Production { lhs: 5, production: &[], }, - // 592 - AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon; + // 599 - AssignDeclaration: Assign HierarchicalIdentifier Equ Expression Semicolon; Production { lhs: 35, production: &[ - ParseType::N(540), - ParseType::N(160), - ParseType::N(148), - ParseType::N(229), + ParseType::N(549), + ParseType::N(163), + ParseType::N(151), + ParseType::N(233), ParseType::N(34), ], }, - // 593 - ModportDeclaration: Modport Identifier LBrace ModportList RBrace; + // 600 - ModportDeclaration: Modport Identifier LBrace ModportList RBrace; Production { - lhs: 375, + lhs: 380, production: &[ - ParseType::N(489), - ParseType::N(380), - ParseType::N(343), - ParseType::N(239), - ParseType::N(374), + ParseType::N(496), + ParseType::N(385), + ParseType::N(348), + ParseType::N(243), + ParseType::N(379), ], }, - // 594 - ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */; + // 601 - ModportList: ModportGroup ModportListList /* Vec */ ModportListOpt /* Option */; Production { - lhs: 380, - production: &[ParseType::N(382), ParseType::N(381), ParseType::N(376)], + lhs: 385, + production: &[ParseType::N(387), ParseType::N(386), ParseType::N(381)], }, - // 595 - ModportListList: Comma ModportGroup ModportListList; + // 602 - ModportListList: Comma ModportGroup ModportListList; Production { - lhs: 381, - production: &[ParseType::N(381), ParseType::N(376), ParseType::N(92)], + lhs: 386, + production: &[ParseType::N(386), ParseType::N(381), ParseType::N(95)], }, - // 596 - ModportListList: ; + // 603 - ModportListList: ; Production { - lhs: 381, + lhs: 386, production: &[], }, - // 597 - ModportListOpt: Comma; + // 604 - ModportListOpt: Comma; Production { - lhs: 382, - production: &[ParseType::N(92)], + lhs: 387, + production: &[ParseType::N(95)], }, - // 598 - ModportListOpt: ; + // 605 - ModportListOpt: ; Production { - lhs: 382, + lhs: 387, production: &[], }, - // 599 - ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup; + // 606 - ModportGroup: ModportGroupList /* Vec */ ModportGroupGroup; Production { - lhs: 376, - production: &[ParseType::N(377), ParseType::N(378)], + lhs: 381, + production: &[ParseType::N(382), ParseType::N(383)], }, - // 600 - ModportGroupGroup: LBrace ModportList RBrace; + // 607 - ModportGroupGroup: LBrace ModportList RBrace; Production { - lhs: 377, - production: &[ParseType::N(489), ParseType::N(380), ParseType::N(343)], + lhs: 382, + production: &[ParseType::N(496), ParseType::N(385), ParseType::N(348)], }, - // 601 - ModportGroupGroup: ModportItem; + // 608 - ModportGroupGroup: ModportItem; Production { - lhs: 377, - production: &[ParseType::N(379)], + lhs: 382, + production: &[ParseType::N(384)], }, - // 602 - ModportGroupList: Attribute ModportGroupList; + // 609 - ModportGroupList: Attribute ModportGroupList; Production { - lhs: 378, - production: &[ParseType::N(378), ParseType::N(43)], + lhs: 383, + production: &[ParseType::N(383), ParseType::N(43)], }, - // 603 - ModportGroupList: ; + // 610 - ModportGroupList: ; Production { - lhs: 378, + lhs: 383, production: &[], }, - // 604 - ModportItem: Identifier Colon Direction; + // 611 - ModportItem: Identifier Colon Direction; Production { - lhs: 379, - production: &[ParseType::N(111), ParseType::N(86), ParseType::N(239)], + lhs: 384, + production: &[ParseType::N(114), ParseType::N(86), ParseType::N(243)], }, - // 605 - EnumDeclaration: Enum Identifier Colon ScalarType LBrace EnumList RBrace; + // 612 - EnumDeclaration: Enum Identifier Colon ScalarType LBrace EnumList RBrace; Production { - lhs: 137, + lhs: 140, production: &[ - ParseType::N(489), - ParseType::N(143), - ParseType::N(343), - ParseType::N(531), + ParseType::N(496), + ParseType::N(146), + ParseType::N(348), + ParseType::N(538), ParseType::N(86), - ParseType::N(239), - ParseType::N(136), + ParseType::N(243), + ParseType::N(139), ], }, - // 606 - EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */; + // 613 - EnumList: EnumGroup EnumListList /* Vec */ EnumListOpt /* Option */; Production { - lhs: 143, - production: &[ParseType::N(145), ParseType::N(144), ParseType::N(138)], + lhs: 146, + production: &[ParseType::N(148), ParseType::N(147), ParseType::N(141)], }, - // 607 - EnumListList: Comma EnumGroup EnumListList; + // 614 - EnumListList: Comma EnumGroup EnumListList; Production { - lhs: 144, - production: &[ParseType::N(144), ParseType::N(138), ParseType::N(92)], + lhs: 147, + production: &[ParseType::N(147), ParseType::N(141), ParseType::N(95)], }, - // 608 - EnumListList: ; + // 615 - EnumListList: ; Production { - lhs: 144, + lhs: 147, production: &[], }, - // 609 - EnumListOpt: Comma; + // 616 - EnumListOpt: Comma; Production { - lhs: 145, - production: &[ParseType::N(92)], + lhs: 148, + production: &[ParseType::N(95)], }, - // 610 - EnumListOpt: ; + // 617 - EnumListOpt: ; Production { - lhs: 145, + lhs: 148, production: &[], }, - // 611 - EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup; + // 618 - EnumGroup: EnumGroupList /* Vec */ EnumGroupGroup; Production { - lhs: 138, - production: &[ParseType::N(139), ParseType::N(140)], + lhs: 141, + production: &[ParseType::N(142), ParseType::N(143)], }, - // 612 - EnumGroupGroup: LBrace EnumList RBrace; + // 619 - EnumGroupGroup: LBrace EnumList RBrace; Production { - lhs: 139, - production: &[ParseType::N(489), ParseType::N(143), ParseType::N(343)], + lhs: 142, + production: &[ParseType::N(496), ParseType::N(146), ParseType::N(348)], }, - // 613 - EnumGroupGroup: EnumItem; + // 620 - EnumGroupGroup: EnumItem; Production { - lhs: 139, - production: &[ParseType::N(141)], + lhs: 142, + production: &[ParseType::N(144)], }, - // 614 - EnumGroupList: Attribute EnumGroupList; + // 621 - EnumGroupList: Attribute EnumGroupList; Production { - lhs: 140, - production: &[ParseType::N(140), ParseType::N(43)], + lhs: 143, + production: &[ParseType::N(143), ParseType::N(43)], }, - // 615 - EnumGroupList: ; + // 622 - EnumGroupList: ; Production { - lhs: 140, + lhs: 143, production: &[], }, - // 616 - EnumItem: Identifier EnumItemOpt /* Option */; + // 623 - EnumItem: Identifier EnumItemOpt /* Option */; Production { - lhs: 141, - production: &[ParseType::N(142), ParseType::N(239)], + lhs: 144, + production: &[ParseType::N(145), ParseType::N(243)], }, - // 617 - EnumItemOpt: Equ Expression; + // 624 - EnumItemOpt: Equ Expression; Production { - lhs: 142, - production: &[ParseType::N(160), ParseType::N(148)], + lhs: 145, + production: &[ParseType::N(163), ParseType::N(151)], }, - // 618 - EnumItemOpt: ; + // 625 - EnumItemOpt: ; Production { - lhs: 142, + lhs: 145, production: &[], }, - // 619 - StructUnion: Struct; + // 626 - StructUnion: Struct; Production { - lhs: 564, - production: &[ParseType::N(561)], + lhs: 573, + production: &[ParseType::N(570)], }, - // 620 - StructUnion: Union; + // 627 - StructUnion: Union; Production { - lhs: 564, - production: &[ParseType::N(591)], + lhs: 573, + production: &[ParseType::N(601)], }, - // 621 - StructUnionDeclaration: StructUnion Identifier LBrace StructUnionList RBrace; + // 628 - StructUnionDeclaration: StructUnion Identifier StructUnionDeclarationOpt /* Option */ LBrace StructUnionList RBrace; Production { - lhs: 565, + lhs: 574, production: &[ - ParseType::N(489), - ParseType::N(570), - ParseType::N(343), - ParseType::N(239), - ParseType::N(564), + ParseType::N(496), + ParseType::N(580), + ParseType::N(348), + ParseType::N(575), + ParseType::N(243), + ParseType::N(573), ], }, - // 622 - StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */; + // 629 - StructUnionDeclarationOpt: WithGenericParameter; Production { - lhs: 570, - production: &[ParseType::N(572), ParseType::N(571), ParseType::N(566)], + lhs: 575, + production: &[ParseType::N(620)], }, - // 623 - StructUnionListList: Comma StructUnionGroup StructUnionListList; + // 630 - StructUnionDeclarationOpt: ; Production { - lhs: 571, - production: &[ParseType::N(571), ParseType::N(566), ParseType::N(92)], + lhs: 575, + production: &[], }, - // 624 - StructUnionListList: ; + // 631 - StructUnionList: StructUnionGroup StructUnionListList /* Vec */ StructUnionListOpt /* Option */; Production { - lhs: 571, + lhs: 580, + production: &[ParseType::N(582), ParseType::N(581), ParseType::N(576)], + }, + // 632 - StructUnionListList: Comma StructUnionGroup StructUnionListList; + Production { + lhs: 581, + production: &[ParseType::N(581), ParseType::N(576), ParseType::N(95)], + }, + // 633 - StructUnionListList: ; + Production { + lhs: 581, production: &[], }, - // 625 - StructUnionListOpt: Comma; + // 634 - StructUnionListOpt: Comma; Production { - lhs: 572, - production: &[ParseType::N(92)], + lhs: 582, + production: &[ParseType::N(95)], }, - // 626 - StructUnionListOpt: ; + // 635 - StructUnionListOpt: ; Production { - lhs: 572, + lhs: 582, production: &[], }, - // 627 - StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup; + // 636 - StructUnionGroup: StructUnionGroupList /* Vec */ StructUnionGroupGroup; Production { - lhs: 566, - production: &[ParseType::N(567), ParseType::N(568)], + lhs: 576, + production: &[ParseType::N(577), ParseType::N(578)], }, - // 628 - StructUnionGroupGroup: LBrace StructUnionList RBrace; + // 637 - StructUnionGroupGroup: LBrace StructUnionList RBrace; Production { - lhs: 567, - production: &[ParseType::N(489), ParseType::N(570), ParseType::N(343)], + lhs: 577, + production: &[ParseType::N(496), ParseType::N(580), ParseType::N(348)], }, - // 629 - StructUnionGroupGroup: StructUnionItem; + // 638 - StructUnionGroupGroup: StructUnionItem; Production { - lhs: 567, - production: &[ParseType::N(569)], + lhs: 577, + production: &[ParseType::N(579)], }, - // 630 - StructUnionGroupList: Attribute StructUnionGroupList; + // 639 - StructUnionGroupList: Attribute StructUnionGroupList; Production { - lhs: 568, - production: &[ParseType::N(568), ParseType::N(43)], + lhs: 578, + production: &[ParseType::N(578), ParseType::N(43)], }, - // 631 - StructUnionGroupList: ; + // 640 - StructUnionGroupList: ; Production { - lhs: 568, + lhs: 578, production: &[], }, - // 632 - StructUnionItem: Identifier Colon ScalarType; + // 641 - StructUnionItem: Identifier Colon ScalarType; Production { - lhs: 569, - production: &[ParseType::N(531), ParseType::N(86), ParseType::N(239)], + lhs: 579, + production: &[ParseType::N(538), ParseType::N(86), ParseType::N(243)], }, - // 633 - InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace; + // 642 - InitialDeclaration: Initial LBrace InitialDeclarationList /* Vec */ RBrace; Production { - lhs: 277, + lhs: 281, production: &[ - ParseType::N(489), - ParseType::N(278), - ParseType::N(343), - ParseType::N(276), + ParseType::N(496), + ParseType::N(282), + ParseType::N(348), + ParseType::N(280), ], }, - // 634 - InitialDeclarationList: Statement InitialDeclarationList; + // 643 - InitialDeclarationList: Statement InitialDeclarationList; Production { - lhs: 278, - production: &[ParseType::N(278), ParseType::N(551)], + lhs: 282, + production: &[ParseType::N(282), ParseType::N(560)], }, - // 635 - InitialDeclarationList: ; + // 644 - InitialDeclarationList: ; Production { - lhs: 278, + lhs: 282, production: &[], }, - // 636 - FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace; + // 645 - FinalDeclaration: Final LBrace FinalDeclarationList /* Vec */ RBrace; Production { - lhs: 202, + lhs: 205, production: &[ - ParseType::N(489), - ParseType::N(203), - ParseType::N(343), - ParseType::N(201), + ParseType::N(496), + ParseType::N(206), + ParseType::N(348), + ParseType::N(204), ], }, - // 637 - FinalDeclarationList: Statement FinalDeclarationList; + // 646 - FinalDeclarationList: Statement FinalDeclarationList; Production { - lhs: 203, - production: &[ParseType::N(203), ParseType::N(551)], + lhs: 206, + production: &[ParseType::N(206), ParseType::N(560)], }, - // 638 - FinalDeclarationList: ; + // 647 - FinalDeclarationList: ; Production { - lhs: 203, + lhs: 206, production: &[], }, - // 639 - InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon; + // 648 - InstDeclaration: Inst Identifier Colon ScopedIdentifier InstDeclarationOpt /* Option */ InstDeclarationOpt0 /* Option */ InstDeclarationOpt1 /* Option */ Semicolon; Production { - lhs: 292, + lhs: 296, production: &[ - ParseType::N(540), - ParseType::N(295), - ParseType::N(294), - ParseType::N(293), - ParseType::N(534), + ParseType::N(549), + ParseType::N(299), + ParseType::N(298), + ParseType::N(297), + ParseType::N(541), ParseType::N(86), - ParseType::N(239), - ParseType::N(291), + ParseType::N(243), + ParseType::N(295), ], }, - // 640 - InstDeclarationOpt1: LParen InstDeclarationOpt2 /* Option */ RParen; + // 649 - InstDeclarationOpt1: LParen InstDeclarationOpt2 /* Option */ RParen; Production { - lhs: 295, - production: &[ParseType::N(495), ParseType::N(296), ParseType::N(349)], + lhs: 299, + production: &[ParseType::N(502), ParseType::N(300), ParseType::N(354)], }, - // 641 - InstDeclarationOpt2: InstPortList; + // 650 - InstDeclarationOpt2: InstPortList; Production { - lhs: 296, - production: &[ParseType::N(312)], + lhs: 300, + production: &[ParseType::N(316)], }, - // 642 - InstDeclarationOpt2: ; + // 651 - InstDeclarationOpt2: ; Production { - lhs: 296, + lhs: 300, production: &[], }, - // 643 - InstDeclarationOpt1: ; + // 652 - InstDeclarationOpt1: ; Production { - lhs: 295, + lhs: 299, production: &[], }, - // 644 - InstDeclarationOpt0: InstParameter; + // 653 - InstDeclarationOpt0: InstParameter; Production { - lhs: 294, - production: &[ParseType::N(297)], + lhs: 298, + production: &[ParseType::N(301)], }, - // 645 - InstDeclarationOpt0: ; + // 654 - InstDeclarationOpt0: ; Production { - lhs: 294, + lhs: 298, production: &[], }, - // 646 - InstDeclarationOpt: Array; + // 655 - InstDeclarationOpt: Array; Production { - lhs: 293, + lhs: 297, production: &[ParseType::N(21)], }, - // 647 - InstDeclarationOpt: ; + // 656 - InstDeclarationOpt: ; Production { - lhs: 293, + lhs: 297, production: &[], }, - // 648 - InstParameter: Hash LParen InstParameterOpt /* Option */ RParen; + // 657 - InstParameter: Hash LParen InstParameterOpt /* Option */ RParen; Production { - lhs: 297, + lhs: 301, production: &[ - ParseType::N(495), - ParseType::N(306), - ParseType::N(349), - ParseType::N(226), + ParseType::N(502), + ParseType::N(310), + ParseType::N(354), + ParseType::N(230), ], }, - // 649 - InstParameterOpt: InstParameterList; + // 658 - InstParameterOpt: InstParameterList; Production { - lhs: 306, - production: &[ParseType::N(303)], + lhs: 310, + production: &[ParseType::N(307)], }, - // 650 - InstParameterOpt: ; + // 659 - InstParameterOpt: ; Production { - lhs: 306, + lhs: 310, production: &[], }, - // 651 - InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */; + // 660 - InstParameterList: InstParameterGroup InstParameterListList /* Vec */ InstParameterListOpt /* Option */; Production { - lhs: 303, - production: &[ParseType::N(305), ParseType::N(304), ParseType::N(298)], + lhs: 307, + production: &[ParseType::N(309), ParseType::N(308), ParseType::N(302)], }, - // 652 - InstParameterListList: Comma InstParameterGroup InstParameterListList; + // 661 - InstParameterListList: Comma InstParameterGroup InstParameterListList; Production { - lhs: 304, - production: &[ParseType::N(304), ParseType::N(298), ParseType::N(92)], + lhs: 308, + production: &[ParseType::N(308), ParseType::N(302), ParseType::N(95)], }, - // 653 - InstParameterListList: ; + // 662 - InstParameterListList: ; Production { - lhs: 304, + lhs: 308, production: &[], }, - // 654 - InstParameterListOpt: Comma; + // 663 - InstParameterListOpt: Comma; Production { - lhs: 305, - production: &[ParseType::N(92)], + lhs: 309, + production: &[ParseType::N(95)], }, - // 655 - InstParameterListOpt: ; + // 664 - InstParameterListOpt: ; Production { - lhs: 305, + lhs: 309, production: &[], }, - // 656 - InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup; + // 665 - InstParameterGroup: InstParameterGroupList /* Vec */ InstParameterGroupGroup; Production { - lhs: 298, - production: &[ParseType::N(299), ParseType::N(300)], + lhs: 302, + production: &[ParseType::N(303), ParseType::N(304)], }, - // 657 - InstParameterGroupGroup: LBrace InstParameterList RBrace; + // 666 - InstParameterGroupGroup: LBrace InstParameterList RBrace; Production { - lhs: 299, - production: &[ParseType::N(489), ParseType::N(303), ParseType::N(343)], + lhs: 303, + production: &[ParseType::N(496), ParseType::N(307), ParseType::N(348)], }, - // 658 - InstParameterGroupGroup: InstParameterItem; + // 667 - InstParameterGroupGroup: InstParameterItem; Production { - lhs: 299, - production: &[ParseType::N(301)], + lhs: 303, + production: &[ParseType::N(305)], }, - // 659 - InstParameterGroupList: Attribute InstParameterGroupList; + // 668 - InstParameterGroupList: Attribute InstParameterGroupList; Production { - lhs: 300, - production: &[ParseType::N(300), ParseType::N(43)], + lhs: 304, + production: &[ParseType::N(304), ParseType::N(43)], }, - // 660 - InstParameterGroupList: ; + // 669 - InstParameterGroupList: ; Production { - lhs: 300, + lhs: 304, production: &[], }, - // 661 - InstParameterItem: Identifier InstParameterItemOpt /* Option */; + // 670 - InstParameterItem: Identifier InstParameterItemOpt /* Option */; Production { - lhs: 301, - production: &[ParseType::N(302), ParseType::N(239)], + lhs: 305, + production: &[ParseType::N(306), ParseType::N(243)], }, - // 662 - InstParameterItemOpt: Colon Expression; + // 671 - InstParameterItemOpt: Colon Expression; Production { - lhs: 302, - production: &[ParseType::N(160), ParseType::N(86)], + lhs: 306, + production: &[ParseType::N(163), ParseType::N(86)], }, - // 663 - InstParameterItemOpt: ; + // 672 - InstParameterItemOpt: ; Production { - lhs: 302, + lhs: 306, production: &[], }, - // 664 - InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */; + // 673 - InstPortList: InstPortGroup InstPortListList /* Vec */ InstPortListOpt /* Option */; Production { - lhs: 312, - production: &[ParseType::N(314), ParseType::N(313), ParseType::N(307)], + lhs: 316, + production: &[ParseType::N(318), ParseType::N(317), ParseType::N(311)], }, - // 665 - InstPortListList: Comma InstPortGroup InstPortListList; + // 674 - InstPortListList: Comma InstPortGroup InstPortListList; Production { - lhs: 313, - production: &[ParseType::N(313), ParseType::N(307), ParseType::N(92)], + lhs: 317, + production: &[ParseType::N(317), ParseType::N(311), ParseType::N(95)], }, - // 666 - InstPortListList: ; + // 675 - InstPortListList: ; Production { - lhs: 313, + lhs: 317, production: &[], }, - // 667 - InstPortListOpt: Comma; + // 676 - InstPortListOpt: Comma; Production { - lhs: 314, - production: &[ParseType::N(92)], + lhs: 318, + production: &[ParseType::N(95)], }, - // 668 - InstPortListOpt: ; + // 677 - InstPortListOpt: ; Production { - lhs: 314, + lhs: 318, production: &[], }, - // 669 - InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup; + // 678 - InstPortGroup: InstPortGroupList /* Vec */ InstPortGroupGroup; Production { - lhs: 307, - production: &[ParseType::N(308), ParseType::N(309)], + lhs: 311, + production: &[ParseType::N(312), ParseType::N(313)], }, - // 670 - InstPortGroupGroup: LBrace InstPortList RBrace; + // 679 - InstPortGroupGroup: LBrace InstPortList RBrace; Production { - lhs: 308, - production: &[ParseType::N(489), ParseType::N(312), ParseType::N(343)], + lhs: 312, + production: &[ParseType::N(496), ParseType::N(316), ParseType::N(348)], }, - // 671 - InstPortGroupGroup: InstPortItem; + // 680 - InstPortGroupGroup: InstPortItem; Production { - lhs: 308, - production: &[ParseType::N(310)], + lhs: 312, + production: &[ParseType::N(314)], }, - // 672 - InstPortGroupList: Attribute InstPortGroupList; + // 681 - InstPortGroupList: Attribute InstPortGroupList; Production { - lhs: 309, - production: &[ParseType::N(309), ParseType::N(43)], + lhs: 313, + production: &[ParseType::N(313), ParseType::N(43)], }, - // 673 - InstPortGroupList: ; + // 682 - InstPortGroupList: ; Production { - lhs: 309, + lhs: 313, production: &[], }, - // 674 - InstPortItem: Identifier InstPortItemOpt /* Option */; + // 683 - InstPortItem: Identifier InstPortItemOpt /* Option */; Production { - lhs: 310, - production: &[ParseType::N(311), ParseType::N(239)], + lhs: 314, + production: &[ParseType::N(315), ParseType::N(243)], }, - // 675 - InstPortItemOpt: Colon Expression; + // 684 - InstPortItemOpt: Colon Expression; Production { - lhs: 311, - production: &[ParseType::N(160), ParseType::N(86)], + lhs: 315, + production: &[ParseType::N(163), ParseType::N(86)], }, - // 676 - InstPortItemOpt: ; + // 685 - InstPortItemOpt: ; Production { - lhs: 311, + lhs: 315, production: &[], }, - // 677 - WithParameter: Hash LParen WithParameterOpt /* Option */ RParen; + // 686 - WithParameter: Hash LParen WithParameterOpt /* Option */ RParen; Production { - lhs: 605, + lhs: 625, production: &[ - ParseType::N(495), - ParseType::N(615), - ParseType::N(349), - ParseType::N(226), + ParseType::N(502), + ParseType::N(635), + ParseType::N(354), + ParseType::N(230), ], }, - // 678 - WithParameterOpt: WithParameterList; + // 687 - WithParameterOpt: WithParameterList; Production { - lhs: 615, - production: &[ParseType::N(612)], + lhs: 635, + production: &[ParseType::N(632)], }, - // 679 - WithParameterOpt: ; + // 688 - WithParameterOpt: ; Production { - lhs: 615, + lhs: 635, production: &[], }, - // 680 - WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */; + // 689 - WithParameterList: WithParameterGroup WithParameterListList /* Vec */ WithParameterListOpt /* Option */; Production { - lhs: 612, - production: &[ParseType::N(614), ParseType::N(613), ParseType::N(606)], + lhs: 632, + production: &[ParseType::N(634), ParseType::N(633), ParseType::N(626)], }, - // 681 - WithParameterListList: Comma WithParameterGroup WithParameterListList; + // 690 - WithParameterListList: Comma WithParameterGroup WithParameterListList; Production { - lhs: 613, - production: &[ParseType::N(613), ParseType::N(606), ParseType::N(92)], + lhs: 633, + production: &[ParseType::N(633), ParseType::N(626), ParseType::N(95)], }, - // 682 - WithParameterListList: ; + // 691 - WithParameterListList: ; Production { - lhs: 613, + lhs: 633, production: &[], }, - // 683 - WithParameterListOpt: Comma; + // 692 - WithParameterListOpt: Comma; Production { - lhs: 614, - production: &[ParseType::N(92)], + lhs: 634, + production: &[ParseType::N(95)], }, - // 684 - WithParameterListOpt: ; + // 693 - WithParameterListOpt: ; Production { - lhs: 614, + lhs: 634, production: &[], }, - // 685 - WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup; + // 694 - WithParameterGroup: WithParameterGroupList /* Vec */ WithParameterGroupGroup; Production { - lhs: 606, - production: &[ParseType::N(607), ParseType::N(608)], + lhs: 626, + production: &[ParseType::N(627), ParseType::N(628)], }, - // 686 - WithParameterGroupGroup: LBrace WithParameterList RBrace; + // 695 - WithParameterGroupGroup: LBrace WithParameterList RBrace; Production { - lhs: 607, - production: &[ParseType::N(489), ParseType::N(612), ParseType::N(343)], + lhs: 627, + production: &[ParseType::N(496), ParseType::N(632), ParseType::N(348)], }, - // 687 - WithParameterGroupGroup: WithParameterItem; + // 696 - WithParameterGroupGroup: WithParameterItem; Production { - lhs: 607, - production: &[ParseType::N(609)], + lhs: 627, + production: &[ParseType::N(629)], }, - // 688 - WithParameterGroupList: Attribute WithParameterGroupList; + // 697 - WithParameterGroupList: Attribute WithParameterGroupList; Production { - lhs: 608, - production: &[ParseType::N(608), ParseType::N(43)], + lhs: 628, + production: &[ParseType::N(628), ParseType::N(43)], }, - // 689 - WithParameterGroupList: ; + // 698 - WithParameterGroupList: ; Production { - lhs: 608, + lhs: 628, production: &[], }, - // 690 - WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0; + // 699 - WithParameterItem: WithParameterItemGroup Identifier Colon WithParameterItemGroup0; Production { - lhs: 609, + lhs: 629, production: &[ - ParseType::N(611), + ParseType::N(631), ParseType::N(86), - ParseType::N(239), - ParseType::N(610), + ParseType::N(243), + ParseType::N(630), ], }, - // 691 - WithParameterItemGroup0: ArrayType Equ Expression; + // 700 - WithParameterItemGroup0: ArrayType Equ Expression; Production { - lhs: 611, - production: &[ParseType::N(160), ParseType::N(148), ParseType::N(29)], + lhs: 631, + production: &[ParseType::N(163), ParseType::N(151), ParseType::N(29)], }, - // 692 - WithParameterItemGroup0: Type Equ TypeExpression; + // 701 - WithParameterItemGroup0: Type Equ TypeExpression; Production { - lhs: 611, - production: &[ParseType::N(578), ParseType::N(148), ParseType::N(576)], + lhs: 631, + production: &[ParseType::N(588), ParseType::N(151), ParseType::N(586)], }, - // 693 - WithParameterItemGroup: Param; + // 702 - WithParameterItemGroup: Param; Production { - lhs: 610, - production: &[ParseType::N(463)], + lhs: 630, + production: &[ParseType::N(470)], }, - // 694 - WithParameterItemGroup: Local; + // 703 - WithParameterItemGroup: Local; Production { - lhs: 610, - production: &[ParseType::N(357)], + lhs: 630, + production: &[ParseType::N(362)], }, - // 695 - PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen; + // 704 - WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle; Production { - lhs: 469, - production: &[ParseType::N(495), ParseType::N(479), ParseType::N(349)], + lhs: 620, + production: &[ParseType::N(493), ParseType::N(622), ParseType::N(88)], }, - // 696 - PortDeclarationOpt: PortDeclarationList; + // 705 - WithGenericParameterList: WithGenericParameterItem WithGenericParameterListList /* Vec */ WithGenericParameterListOpt /* Option */; Production { - lhs: 479, - production: &[ParseType::N(476)], + lhs: 622, + production: &[ParseType::N(624), ParseType::N(623), ParseType::N(621)], }, - // 697 - PortDeclarationOpt: ; + // 706 - WithGenericParameterListList: Comma WithGenericParameterItem WithGenericParameterListList; Production { - lhs: 479, + lhs: 623, + production: &[ParseType::N(623), ParseType::N(621), ParseType::N(95)], + }, + // 707 - WithGenericParameterListList: ; + Production { + lhs: 623, + production: &[], + }, + // 708 - WithGenericParameterListOpt: Comma; + Production { + lhs: 624, + production: &[ParseType::N(95)], + }, + // 709 - WithGenericParameterListOpt: ; + Production { + lhs: 624, + production: &[], + }, + // 710 - WithGenericParameterItem: Identifier; + Production { + lhs: 621, + production: &[ParseType::N(243)], + }, + // 711 - WithGenericArgument: ColonColonLAngle Push(2) WithGenericArgumentList RAngle Pop; + Production { + lhs: 615, + production: &[ + ParseType::Pop, + ParseType::N(493), + ParseType::N(617), + ParseType::Push(2), + ParseType::N(88), + ], + }, + // 712 - WithGenericArgumentList: WithGenericArgumentItem WithGenericArgumentListList /* Vec */ WithGenericArgumentListOpt /* Option */; + Production { + lhs: 617, + production: &[ParseType::N(619), ParseType::N(618), ParseType::N(616)], + }, + // 713 - WithGenericArgumentListList: Comma WithGenericArgumentItem WithGenericArgumentListList; + Production { + lhs: 618, + production: &[ParseType::N(618), ParseType::N(616), ParseType::N(95)], + }, + // 714 - WithGenericArgumentListList: ; + Production { + lhs: 618, + production: &[], + }, + // 715 - WithGenericArgumentListOpt: Comma; + Production { + lhs: 619, + production: &[ParseType::N(95)], + }, + // 716 - WithGenericArgumentListOpt: ; + Production { + lhs: 619, production: &[], }, - // 698 - PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */; + // 717 - WithGenericArgumentItem: ScopedIdentifier; + Production { + lhs: 616, + production: &[ParseType::N(541)], + }, + // 718 - WithGenericArgumentItem: Number; + Production { + lhs: 616, + production: &[ParseType::N(417)], + }, + // 719 - PortDeclaration: LParen PortDeclarationOpt /* Option */ RParen; Production { lhs: 476, - production: &[ParseType::N(478), ParseType::N(477), ParseType::N(470)], + production: &[ParseType::N(502), ParseType::N(486), ParseType::N(354)], }, - // 699 - PortDeclarationListList: Comma PortDeclarationGroup PortDeclarationListList; + // 720 - PortDeclarationOpt: PortDeclarationList; Production { - lhs: 477, - production: &[ParseType::N(477), ParseType::N(470), ParseType::N(92)], + lhs: 486, + production: &[ParseType::N(483)], }, - // 700 - PortDeclarationListList: ; + // 721 - PortDeclarationOpt: ; Production { - lhs: 477, + lhs: 486, production: &[], }, - // 701 - PortDeclarationListOpt: Comma; + // 722 - PortDeclarationList: PortDeclarationGroup PortDeclarationListList /* Vec */ PortDeclarationListOpt /* Option */; Production { - lhs: 478, - production: &[ParseType::N(92)], + lhs: 483, + production: &[ParseType::N(485), ParseType::N(484), ParseType::N(477)], }, - // 702 - PortDeclarationListOpt: ; + // 723 - PortDeclarationListList: Comma PortDeclarationGroup PortDeclarationListList; Production { - lhs: 478, + lhs: 484, + production: &[ParseType::N(484), ParseType::N(477), ParseType::N(95)], + }, + // 724 - PortDeclarationListList: ; + Production { + lhs: 484, production: &[], }, - // 703 - PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup; + // 725 - PortDeclarationListOpt: Comma; Production { - lhs: 470, - production: &[ParseType::N(471), ParseType::N(472)], + lhs: 485, + production: &[ParseType::N(95)], }, - // 704 - PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace; + // 726 - PortDeclarationListOpt: ; Production { - lhs: 471, - production: &[ParseType::N(489), ParseType::N(476), ParseType::N(343)], + lhs: 485, + production: &[], }, - // 705 - PortDeclarationGroupGroup: PortDeclarationItem; + // 727 - PortDeclarationGroup: PortDeclarationGroupList /* Vec */ PortDeclarationGroupGroup; Production { - lhs: 471, - production: &[ParseType::N(473)], + lhs: 477, + production: &[ParseType::N(478), ParseType::N(479)], }, - // 706 - PortDeclarationGroupList: Attribute PortDeclarationGroupList; + // 728 - PortDeclarationGroupGroup: LBrace PortDeclarationList RBrace; Production { - lhs: 472, - production: &[ParseType::N(472), ParseType::N(43)], + lhs: 478, + production: &[ParseType::N(496), ParseType::N(483), ParseType::N(348)], }, - // 707 - PortDeclarationGroupList: ; + // 729 - PortDeclarationGroupGroup: PortDeclarationItem; Production { - lhs: 472, + lhs: 478, + production: &[ParseType::N(480)], + }, + // 730 - PortDeclarationGroupList: Attribute PortDeclarationGroupList; + Production { + lhs: 479, + production: &[ParseType::N(479), ParseType::N(43)], + }, + // 731 - PortDeclarationGroupList: ; + Production { + lhs: 479, production: &[], }, - // 708 - PortDeclarationItem: Identifier Colon PortDeclarationItemGroup; + // 732 - PortDeclarationItem: Identifier Colon PortDeclarationItemGroup; Production { - lhs: 473, - production: &[ParseType::N(474), ParseType::N(86), ParseType::N(239)], + lhs: 480, + production: &[ParseType::N(481), ParseType::N(86), ParseType::N(243)], }, - // 709 - PortDeclarationItemGroup: Direction ArrayType; + // 733 - PortDeclarationItemGroup: Direction ArrayType; Production { - lhs: 474, - production: &[ParseType::N(29), ParseType::N(111)], + lhs: 481, + production: &[ParseType::N(29), ParseType::N(114)], }, - // 710 - PortDeclarationItemGroup: Interface PortDeclarationItemOpt /* Option */; + // 734 - PortDeclarationItemGroup: Interface PortDeclarationItemOpt /* Option */; Production { - lhs: 474, - production: &[ParseType::N(475), ParseType::N(318)], + lhs: 481, + production: &[ParseType::N(482), ParseType::N(322)], }, - // 711 - PortDeclarationItemOpt: Array; + // 735 - PortDeclarationItemOpt: Array; Production { - lhs: 475, + lhs: 482, production: &[ParseType::N(21)], }, - // 712 - PortDeclarationItemOpt: ; + // 736 - PortDeclarationItemOpt: ; Production { - lhs: 475, + lhs: 482, production: &[], }, - // 713 - Direction: Input; + // 737 - Direction: Input; Production { - lhs: 111, - production: &[ParseType::N(284)], + lhs: 114, + production: &[ParseType::N(288)], }, - // 714 - Direction: Output; + // 738 - Direction: Output; Production { - lhs: 111, - production: &[ParseType::N(445)], + lhs: 114, + production: &[ParseType::N(451)], }, - // 715 - Direction: Inout; + // 739 - Direction: Inout; Production { - lhs: 111, - production: &[ParseType::N(281)], + lhs: 114, + production: &[ParseType::N(285)], }, - // 716 - Direction: Ref; + // 740 - Direction: Ref; Production { - lhs: 111, - production: &[ParseType::N(506)], + lhs: 114, + production: &[ParseType::N(513)], }, - // 717 - Direction: Modport; + // 741 - Direction: Modport; Production { - lhs: 111, - production: &[ParseType::N(374)], + lhs: 114, + production: &[ParseType::N(379)], }, - // 718 - FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace; + // 742 - FunctionDeclaration: Function Identifier FunctionDeclarationOpt /* Option */ FunctionDeclarationOpt0 /* Option */ FunctionDeclarationOpt1 /* Option */ LBrace FunctionDeclarationList /* Vec */ RBrace; Production { - lhs: 219, + lhs: 222, production: &[ - ParseType::N(489), - ParseType::N(220), - ParseType::N(343), - ParseType::N(222), - ParseType::N(221), - ParseType::N(239), - ParseType::N(216), + ParseType::N(496), + ParseType::N(223), + ParseType::N(348), + ParseType::N(226), + ParseType::N(225), + ParseType::N(224), + ParseType::N(243), + ParseType::N(219), ], }, - // 719 - FunctionDeclarationList: FunctionItem FunctionDeclarationList; + // 743 - FunctionDeclarationList: FunctionItem FunctionDeclarationList; Production { - lhs: 220, - production: &[ParseType::N(220), ParseType::N(223)], + lhs: 223, + production: &[ParseType::N(223), ParseType::N(227)], }, - // 720 - FunctionDeclarationList: ; + // 744 - FunctionDeclarationList: ; Production { - lhs: 220, + lhs: 223, production: &[], }, - // 721 - FunctionDeclarationOpt0: MinusGT ScalarType; + // 745 - FunctionDeclarationOpt1: MinusGT ScalarType; Production { - lhs: 222, - production: &[ParseType::N(531), ParseType::N(371)], + lhs: 226, + production: &[ParseType::N(538), ParseType::N(376)], }, - // 722 - FunctionDeclarationOpt0: ; + // 746 - FunctionDeclarationOpt1: ; Production { - lhs: 222, + lhs: 226, production: &[], }, - // 723 - FunctionDeclarationOpt: PortDeclaration; + // 747 - FunctionDeclarationOpt0: PortDeclaration; Production { - lhs: 221, - production: &[ParseType::N(469)], + lhs: 225, + production: &[ParseType::N(476)], }, - // 724 - FunctionDeclarationOpt: ; + // 748 - FunctionDeclarationOpt0: ; Production { - lhs: 221, + lhs: 225, production: &[], }, - // 725 - FunctionItem: VarDeclaration; + // 749 - FunctionDeclarationOpt: WithGenericParameter; Production { - lhs: 223, - production: &[ParseType::N(595)], + lhs: 224, + production: &[ParseType::N(620)], }, - // 726 - FunctionItem: Statement; + // 750 - FunctionDeclarationOpt: ; Production { - lhs: 223, - production: &[ParseType::N(551)], + lhs: 224, + production: &[], }, - // 727 - ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon; + // 751 - FunctionItem: VarDeclaration; Production { - lhs: 265, + lhs: 227, + production: &[ParseType::N(605)], + }, + // 752 - FunctionItem: Statement; + Production { + lhs: 227, + production: &[ParseType::N(560)], + }, + // 753 - ImportDeclaration: Import ScopedIdentifier ImportDeclarationOpt /* Option */ Semicolon; + Production { + lhs: 269, production: &[ - ParseType::N(540), - ParseType::N(266), - ParseType::N(534), - ParseType::N(264), + ParseType::N(549), + ParseType::N(270), + ParseType::N(541), + ParseType::N(268), ], }, - // 728 - ImportDeclarationOpt: ColonColon Star; + // 754 - ImportDeclarationOpt: ColonColon Star; Production { - lhs: 266, - production: &[ParseType::N(546), ParseType::N(87)], + lhs: 270, + production: &[ParseType::N(555), ParseType::N(87)], }, - // 729 - ImportDeclarationOpt: ; + // 755 - ImportDeclarationOpt: ; Production { - lhs: 266, + lhs: 270, production: &[], }, - // 730 - ExportDeclaration: Export ExportDeclarationGroup Semicolon; + // 756 - ExportDeclaration: Export ExportDeclarationGroup Semicolon; Production { - lhs: 155, - production: &[ParseType::N(540), ParseType::N(156), ParseType::N(154)], + lhs: 158, + production: &[ParseType::N(549), ParseType::N(159), ParseType::N(157)], }, - // 731 - ExportDeclarationGroup: Star; + // 757 - ExportDeclarationGroup: Star; Production { - lhs: 156, - production: &[ParseType::N(546)], + lhs: 159, + production: &[ParseType::N(555)], }, - // 732 - ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */; + // 758 - ExportDeclarationGroup: ScopedIdentifier ExportDeclarationOpt /* Option */; Production { - lhs: 156, - production: &[ParseType::N(157), ParseType::N(534)], + lhs: 159, + production: &[ParseType::N(160), ParseType::N(541)], }, - // 733 - ExportDeclarationOpt: ColonColon Star; + // 759 - ExportDeclarationOpt: ColonColon Star; Production { - lhs: 157, - production: &[ParseType::N(546), ParseType::N(87)], + lhs: 160, + production: &[ParseType::N(555), ParseType::N(87)], }, - // 734 - ExportDeclarationOpt: ; + // 760 - ExportDeclarationOpt: ; Production { - lhs: 157, + lhs: 160, production: &[], }, - // 735 - ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace; + // 761 - ModuleDeclaration: ModuleDeclarationOpt /* Option */ Module Identifier ModuleDeclarationOpt0 /* Option */ ModuleDeclarationOpt1 /* Option */ ModuleDeclarationOpt2 /* Option */ LBrace ModuleDeclarationList /* Vec */ RBrace; Production { - lhs: 386, + lhs: 391, production: &[ - ParseType::N(489), - ParseType::N(387), - ParseType::N(343), + ParseType::N(496), + ParseType::N(392), + ParseType::N(348), + ParseType::N(396), + ParseType::N(395), + ParseType::N(394), + ParseType::N(243), ParseType::N(390), - ParseType::N(389), - ParseType::N(239), - ParseType::N(385), - ParseType::N(388), + ParseType::N(393), ], }, - // 736 - ModuleDeclarationList: ModuleGroup ModuleDeclarationList; + // 762 - ModuleDeclarationList: ModuleGroup ModuleDeclarationList; Production { - lhs: 387, - production: &[ParseType::N(387), ParseType::N(393)], + lhs: 392, + production: &[ParseType::N(392), ParseType::N(399)], }, - // 737 - ModuleDeclarationList: ; + // 763 - ModuleDeclarationList: ; Production { - lhs: 387, + lhs: 392, production: &[], }, - // 738 - ModuleDeclarationOpt1: PortDeclaration; + // 764 - ModuleDeclarationOpt2: PortDeclaration; Production { - lhs: 390, - production: &[ParseType::N(469)], + lhs: 396, + production: &[ParseType::N(476)], }, - // 739 - ModuleDeclarationOpt1: ; + // 765 - ModuleDeclarationOpt2: ; Production { - lhs: 390, + lhs: 396, production: &[], }, - // 740 - ModuleDeclarationOpt0: WithParameter; + // 766 - ModuleDeclarationOpt1: WithParameter; Production { - lhs: 389, - production: &[ParseType::N(605)], + lhs: 395, + production: &[ParseType::N(625)], }, - // 741 - ModuleDeclarationOpt0: ; + // 767 - ModuleDeclarationOpt1: ; Production { - lhs: 389, + lhs: 395, production: &[], }, - // 742 - ModuleDeclarationOpt: Pub; + // 768 - ModuleDeclarationOpt0: WithGenericParameter; Production { - lhs: 388, - production: &[ParseType::N(480)], + lhs: 394, + production: &[ParseType::N(620)], }, - // 743 - ModuleDeclarationOpt: ; + // 769 - ModuleDeclarationOpt0: ; Production { - lhs: 388, + lhs: 394, production: &[], }, - // 744 - ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */; + // 770 - ModuleDeclarationOpt: Pub; Production { - lhs: 397, + lhs: 393, + production: &[ParseType::N(487)], + }, + // 771 - ModuleDeclarationOpt: ; + Production { + lhs: 393, + production: &[], + }, + // 772 - ModuleIfDeclaration: If Expression ModuleNamedBlock ModuleIfDeclarationList /* Vec */ ModuleIfDeclarationOpt /* Option */; + Production { + lhs: 403, production: &[ - ParseType::N(399), - ParseType::N(398), - ParseType::N(401), - ParseType::N(160), - ParseType::N(244), + ParseType::N(405), + ParseType::N(404), + ParseType::N(407), + ParseType::N(163), + ParseType::N(248), ], }, - // 745 - ModuleIfDeclarationList: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList; + // 773 - ModuleIfDeclarationList: Else If Expression ModuleOptionalNamedBlock ModuleIfDeclarationList; Production { - lhs: 398, + lhs: 404, production: &[ - ParseType::N(398), - ParseType::N(403), - ParseType::N(160), - ParseType::N(244), - ParseType::N(124), + ParseType::N(404), + ParseType::N(409), + ParseType::N(163), + ParseType::N(248), + ParseType::N(127), ], }, - // 746 - ModuleIfDeclarationList: ; + // 774 - ModuleIfDeclarationList: ; Production { - lhs: 398, + lhs: 404, production: &[], }, - // 747 - ModuleIfDeclarationOpt: Else ModuleOptionalNamedBlock; + // 775 - ModuleIfDeclarationOpt: Else ModuleOptionalNamedBlock; Production { - lhs: 399, - production: &[ParseType::N(403), ParseType::N(124)], + lhs: 405, + production: &[ParseType::N(409), ParseType::N(127)], }, - // 748 - ModuleIfDeclarationOpt: ; + // 776 - ModuleIfDeclarationOpt: ; Production { - lhs: 399, + lhs: 405, production: &[], }, - // 749 - ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock; + // 777 - ModuleForDeclaration: For Identifier In Range ModuleForDeclarationOpt /* Option */ ModuleNamedBlock; Production { - lhs: 391, + lhs: 397, production: &[ - ParseType::N(401), - ParseType::N(392), - ParseType::N(498), - ParseType::N(269), - ParseType::N(239), - ParseType::N(210), + ParseType::N(407), + ParseType::N(398), + ParseType::N(505), + ParseType::N(273), + ParseType::N(243), + ParseType::N(213), ], }, - // 750 - ModuleForDeclarationOpt: Step AssignmentOperator Expression; + // 778 - ModuleForDeclarationOpt: Step AssignmentOperator Expression; Production { - lhs: 392, - production: &[ParseType::N(160), ParseType::N(40), ParseType::N(552)], + lhs: 398, + production: &[ParseType::N(163), ParseType::N(40), ParseType::N(561)], }, - // 751 - ModuleForDeclarationOpt: ; + // 779 - ModuleForDeclarationOpt: ; Production { - lhs: 392, + lhs: 398, production: &[], }, - // 752 - ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace; + // 780 - ModuleNamedBlock: Colon Identifier LBrace ModuleNamedBlockList /* Vec */ RBrace; Production { - lhs: 401, + lhs: 407, production: &[ - ParseType::N(489), - ParseType::N(402), - ParseType::N(343), - ParseType::N(239), + ParseType::N(496), + ParseType::N(408), + ParseType::N(348), + ParseType::N(243), ParseType::N(86), ], }, - // 753 - ModuleNamedBlockList: ModuleGroup ModuleNamedBlockList; + // 781 - ModuleNamedBlockList: ModuleGroup ModuleNamedBlockList; Production { - lhs: 402, - production: &[ParseType::N(402), ParseType::N(393)], + lhs: 408, + production: &[ParseType::N(408), ParseType::N(399)], }, - // 754 - ModuleNamedBlockList: ; + // 782 - ModuleNamedBlockList: ; Production { - lhs: 402, + lhs: 408, production: &[], }, - // 755 - ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace; + // 783 - ModuleOptionalNamedBlock: ModuleOptionalNamedBlockOpt /* Option */ LBrace ModuleOptionalNamedBlockList /* Vec */ RBrace; Production { - lhs: 403, + lhs: 409, production: &[ - ParseType::N(489), - ParseType::N(404), - ParseType::N(343), - ParseType::N(405), + ParseType::N(496), + ParseType::N(410), + ParseType::N(348), + ParseType::N(411), ], }, - // 756 - ModuleOptionalNamedBlockList: ModuleGroup ModuleOptionalNamedBlockList; + // 784 - ModuleOptionalNamedBlockList: ModuleGroup ModuleOptionalNamedBlockList; Production { - lhs: 404, - production: &[ParseType::N(404), ParseType::N(393)], + lhs: 410, + production: &[ParseType::N(410), ParseType::N(399)], }, - // 757 - ModuleOptionalNamedBlockList: ; + // 785 - ModuleOptionalNamedBlockList: ; Production { - lhs: 404, + lhs: 410, production: &[], }, - // 758 - ModuleOptionalNamedBlockOpt: Colon Identifier; + // 786 - ModuleOptionalNamedBlockOpt: Colon Identifier; Production { - lhs: 405, - production: &[ParseType::N(239), ParseType::N(86)], + lhs: 411, + production: &[ParseType::N(243), ParseType::N(86)], }, - // 759 - ModuleOptionalNamedBlockOpt: ; + // 787 - ModuleOptionalNamedBlockOpt: ; Production { - lhs: 405, + lhs: 411, production: &[], }, - // 760 - ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup; + // 788 - ModuleGroup: ModuleGroupList /* Vec */ ModuleGroupGroup; Production { - lhs: 393, - production: &[ParseType::N(394), ParseType::N(396)], + lhs: 399, + production: &[ParseType::N(400), ParseType::N(402)], }, - // 761 - ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace; + // 789 - ModuleGroupGroup: LBrace ModuleGroupGroupList /* Vec */ RBrace; Production { - lhs: 394, - production: &[ParseType::N(489), ParseType::N(395), ParseType::N(343)], + lhs: 400, + production: &[ParseType::N(496), ParseType::N(401), ParseType::N(348)], }, - // 762 - ModuleGroupGroupList: ModuleGroup ModuleGroupGroupList; + // 790 - ModuleGroupGroupList: ModuleGroup ModuleGroupGroupList; Production { - lhs: 395, - production: &[ParseType::N(395), ParseType::N(393)], + lhs: 401, + production: &[ParseType::N(401), ParseType::N(399)], }, - // 763 - ModuleGroupGroupList: ; + // 791 - ModuleGroupGroupList: ; Production { - lhs: 395, + lhs: 401, production: &[], }, - // 764 - ModuleGroupGroup: ModuleItem; + // 792 - ModuleGroupGroup: ModuleItem; Production { - lhs: 394, - production: &[ParseType::N(400)], + lhs: 400, + production: &[ParseType::N(406)], }, - // 765 - ModuleGroupList: Attribute ModuleGroupList; + // 793 - ModuleGroupList: Attribute ModuleGroupList; Production { - lhs: 396, - production: &[ParseType::N(396), ParseType::N(43)], + lhs: 402, + production: &[ParseType::N(402), ParseType::N(43)], }, - // 766 - ModuleGroupList: ; + // 794 - ModuleGroupList: ; Production { - lhs: 396, + lhs: 402, production: &[], }, - // 767 - ModuleItem: LetDeclaration; + // 795 - ModuleItem: LetDeclaration; Production { - lhs: 400, - production: &[ParseType::N(353)], + lhs: 406, + production: &[ParseType::N(358)], }, - // 768 - ModuleItem: VarDeclaration; + // 796 - ModuleItem: VarDeclaration; Production { - lhs: 400, - production: &[ParseType::N(595)], + lhs: 406, + production: &[ParseType::N(605)], }, - // 769 - ModuleItem: InstDeclaration; + // 797 - ModuleItem: InstDeclaration; Production { - lhs: 400, - production: &[ParseType::N(292)], + lhs: 406, + production: &[ParseType::N(296)], }, - // 770 - ModuleItem: TypeDefDeclaration; + // 798 - ModuleItem: TypeDefDeclaration; Production { - lhs: 400, - production: &[ParseType::N(577)], + lhs: 406, + production: &[ParseType::N(587)], }, - // 771 - ModuleItem: LocalDeclaration; + // 799 - ModuleItem: LocalDeclaration; Production { - lhs: 400, - production: &[ParseType::N(358)], + lhs: 406, + production: &[ParseType::N(363)], }, - // 772 - ModuleItem: AlwaysFfDeclaration; + // 800 - ModuleItem: AlwaysFfDeclaration; Production { - lhs: 400, + lhs: 406, production: &[ParseType::N(10)], }, - // 773 - ModuleItem: AlwaysCombDeclaration; + // 801 - ModuleItem: AlwaysCombDeclaration; Production { - lhs: 400, + lhs: 406, production: &[ParseType::N(4)], }, - // 774 - ModuleItem: AssignDeclaration; + // 802 - ModuleItem: AssignDeclaration; Production { - lhs: 400, + lhs: 406, production: &[ParseType::N(35)], }, - // 775 - ModuleItem: FunctionDeclaration; + // 803 - ModuleItem: FunctionDeclaration; Production { - lhs: 400, - production: &[ParseType::N(219)], + lhs: 406, + production: &[ParseType::N(222)], }, - // 776 - ModuleItem: ModuleIfDeclaration; + // 804 - ModuleItem: ModuleIfDeclaration; Production { - lhs: 400, - production: &[ParseType::N(397)], + lhs: 406, + production: &[ParseType::N(403)], }, - // 777 - ModuleItem: ModuleForDeclaration; + // 805 - ModuleItem: ModuleForDeclaration; Production { - lhs: 400, - production: &[ParseType::N(391)], + lhs: 406, + production: &[ParseType::N(397)], }, - // 778 - ModuleItem: EnumDeclaration; + // 806 - ModuleItem: EnumDeclaration; Production { - lhs: 400, - production: &[ParseType::N(137)], + lhs: 406, + production: &[ParseType::N(140)], }, - // 779 - ModuleItem: StructUnionDeclaration; + // 807 - ModuleItem: StructUnionDeclaration; Production { - lhs: 400, - production: &[ParseType::N(565)], + lhs: 406, + production: &[ParseType::N(574)], }, - // 780 - ModuleItem: ModuleNamedBlock; + // 808 - ModuleItem: ModuleNamedBlock; Production { - lhs: 400, - production: &[ParseType::N(401)], + lhs: 406, + production: &[ParseType::N(407)], }, - // 781 - ModuleItem: ImportDeclaration; + // 809 - ModuleItem: ImportDeclaration; Production { - lhs: 400, - production: &[ParseType::N(265)], + lhs: 406, + production: &[ParseType::N(269)], }, - // 782 - ModuleItem: InitialDeclaration; + // 810 - ModuleItem: InitialDeclaration; Production { - lhs: 400, - production: &[ParseType::N(277)], + lhs: 406, + production: &[ParseType::N(281)], }, - // 783 - ModuleItem: FinalDeclaration; + // 811 - ModuleItem: FinalDeclaration; Production { - lhs: 400, - production: &[ParseType::N(202)], + lhs: 406, + production: &[ParseType::N(205)], }, - // 784 - InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace; + // 812 - InterfaceDeclaration: InterfaceDeclarationOpt /* Option */ Interface Identifier InterfaceDeclarationOpt0 /* Option */ InterfaceDeclarationOpt1 /* Option */ LBrace InterfaceDeclarationList /* Vec */ RBrace; Production { - lhs: 319, + lhs: 323, production: &[ - ParseType::N(489), - ParseType::N(320), - ParseType::N(343), + ParseType::N(496), + ParseType::N(324), + ParseType::N(348), + ParseType::N(327), + ParseType::N(326), + ParseType::N(243), ParseType::N(322), - ParseType::N(239), - ParseType::N(318), - ParseType::N(321), + ParseType::N(325), ], }, - // 785 - InterfaceDeclarationList: InterfaceGroup InterfaceDeclarationList; + // 813 - InterfaceDeclarationList: InterfaceGroup InterfaceDeclarationList; Production { - lhs: 320, - production: &[ParseType::N(320), ParseType::N(325)], + lhs: 324, + production: &[ParseType::N(324), ParseType::N(330)], }, - // 786 - InterfaceDeclarationList: ; + // 814 - InterfaceDeclarationList: ; Production { - lhs: 320, + lhs: 324, production: &[], }, - // 787 - InterfaceDeclarationOpt0: WithParameter; + // 815 - InterfaceDeclarationOpt1: WithParameter; Production { - lhs: 322, - production: &[ParseType::N(605)], + lhs: 327, + production: &[ParseType::N(625)], }, - // 788 - InterfaceDeclarationOpt0: ; + // 816 - InterfaceDeclarationOpt1: ; Production { - lhs: 322, + lhs: 327, production: &[], }, - // 789 - InterfaceDeclarationOpt: Pub; + // 817 - InterfaceDeclarationOpt0: WithGenericParameter; Production { - lhs: 321, - production: &[ParseType::N(480)], + lhs: 326, + production: &[ParseType::N(620)], }, - // 790 - InterfaceDeclarationOpt: ; + // 818 - InterfaceDeclarationOpt0: ; Production { - lhs: 321, + lhs: 326, production: &[], }, - // 791 - InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */; + // 819 - InterfaceDeclarationOpt: Pub; Production { - lhs: 329, + lhs: 325, + production: &[ParseType::N(487)], + }, + // 820 - InterfaceDeclarationOpt: ; + Production { + lhs: 325, + production: &[], + }, + // 821 - InterfaceIfDeclaration: If Expression InterfaceNamedBlock InterfaceIfDeclarationList /* Vec */ InterfaceIfDeclarationOpt /* Option */; + Production { + lhs: 334, production: &[ - ParseType::N(331), - ParseType::N(330), - ParseType::N(333), - ParseType::N(160), - ParseType::N(244), + ParseType::N(336), + ParseType::N(335), + ParseType::N(338), + ParseType::N(163), + ParseType::N(248), ], }, - // 792 - InterfaceIfDeclarationList: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList; + // 822 - InterfaceIfDeclarationList: Else If Expression InterfaceOptionalNamedBlock InterfaceIfDeclarationList; Production { - lhs: 330, + lhs: 335, production: &[ - ParseType::N(330), ParseType::N(335), - ParseType::N(160), - ParseType::N(244), - ParseType::N(124), + ParseType::N(340), + ParseType::N(163), + ParseType::N(248), + ParseType::N(127), ], }, - // 793 - InterfaceIfDeclarationList: ; + // 823 - InterfaceIfDeclarationList: ; Production { - lhs: 330, + lhs: 335, production: &[], }, - // 794 - InterfaceIfDeclarationOpt: Else InterfaceOptionalNamedBlock; + // 824 - InterfaceIfDeclarationOpt: Else InterfaceOptionalNamedBlock; Production { - lhs: 331, - production: &[ParseType::N(335), ParseType::N(124)], + lhs: 336, + production: &[ParseType::N(340), ParseType::N(127)], }, - // 795 - InterfaceIfDeclarationOpt: ; + // 825 - InterfaceIfDeclarationOpt: ; Production { - lhs: 331, + lhs: 336, production: &[], }, - // 796 - InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock; + // 826 - InterfaceForDeclaration: For Identifier In Range InterfaceForDeclarationOpt /* Option */ InterfaceNamedBlock; Production { - lhs: 323, + lhs: 328, production: &[ - ParseType::N(333), - ParseType::N(324), - ParseType::N(498), - ParseType::N(269), - ParseType::N(239), - ParseType::N(210), + ParseType::N(338), + ParseType::N(329), + ParseType::N(505), + ParseType::N(273), + ParseType::N(243), + ParseType::N(213), ], }, - // 797 - InterfaceForDeclarationOpt: Step AssignmentOperator Expression; + // 827 - InterfaceForDeclarationOpt: Step AssignmentOperator Expression; Production { - lhs: 324, - production: &[ParseType::N(160), ParseType::N(40), ParseType::N(552)], + lhs: 329, + production: &[ParseType::N(163), ParseType::N(40), ParseType::N(561)], }, - // 798 - InterfaceForDeclarationOpt: ; + // 828 - InterfaceForDeclarationOpt: ; Production { - lhs: 324, + lhs: 329, production: &[], }, - // 799 - InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace; + // 829 - InterfaceNamedBlock: Colon Identifier LBrace InterfaceNamedBlockList /* Vec */ RBrace; Production { - lhs: 333, + lhs: 338, production: &[ - ParseType::N(489), - ParseType::N(334), - ParseType::N(343), - ParseType::N(239), + ParseType::N(496), + ParseType::N(339), + ParseType::N(348), + ParseType::N(243), ParseType::N(86), ], }, - // 800 - InterfaceNamedBlockList: InterfaceGroup InterfaceNamedBlockList; + // 830 - InterfaceNamedBlockList: InterfaceGroup InterfaceNamedBlockList; Production { - lhs: 334, - production: &[ParseType::N(334), ParseType::N(325)], + lhs: 339, + production: &[ParseType::N(339), ParseType::N(330)], }, - // 801 - InterfaceNamedBlockList: ; + // 831 - InterfaceNamedBlockList: ; Production { - lhs: 334, + lhs: 339, production: &[], }, - // 802 - InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace; + // 832 - InterfaceOptionalNamedBlock: InterfaceOptionalNamedBlockOpt /* Option */ LBrace InterfaceOptionalNamedBlockList /* Vec */ RBrace; Production { - lhs: 335, + lhs: 340, production: &[ - ParseType::N(489), - ParseType::N(336), - ParseType::N(343), - ParseType::N(337), + ParseType::N(496), + ParseType::N(341), + ParseType::N(348), + ParseType::N(342), ], }, - // 803 - InterfaceOptionalNamedBlockList: InterfaceGroup InterfaceOptionalNamedBlockList; + // 833 - InterfaceOptionalNamedBlockList: InterfaceGroup InterfaceOptionalNamedBlockList; Production { - lhs: 336, - production: &[ParseType::N(336), ParseType::N(325)], + lhs: 341, + production: &[ParseType::N(341), ParseType::N(330)], }, - // 804 - InterfaceOptionalNamedBlockList: ; + // 834 - InterfaceOptionalNamedBlockList: ; Production { - lhs: 336, + lhs: 341, production: &[], }, - // 805 - InterfaceOptionalNamedBlockOpt: Colon Identifier; + // 835 - InterfaceOptionalNamedBlockOpt: Colon Identifier; Production { - lhs: 337, - production: &[ParseType::N(239), ParseType::N(86)], + lhs: 342, + production: &[ParseType::N(243), ParseType::N(86)], }, - // 806 - InterfaceOptionalNamedBlockOpt: ; + // 836 - InterfaceOptionalNamedBlockOpt: ; Production { - lhs: 337, + lhs: 342, production: &[], }, - // 807 - InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup; + // 837 - InterfaceGroup: InterfaceGroupList /* Vec */ InterfaceGroupGroup; Production { - lhs: 325, - production: &[ParseType::N(326), ParseType::N(328)], + lhs: 330, + production: &[ParseType::N(331), ParseType::N(333)], }, - // 808 - InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace; + // 838 - InterfaceGroupGroup: LBrace InterfaceGroupGroupList /* Vec */ RBrace; Production { - lhs: 326, - production: &[ParseType::N(489), ParseType::N(327), ParseType::N(343)], + lhs: 331, + production: &[ParseType::N(496), ParseType::N(332), ParseType::N(348)], }, - // 809 - InterfaceGroupGroupList: InterfaceGroup InterfaceGroupGroupList; + // 839 - InterfaceGroupGroupList: InterfaceGroup InterfaceGroupGroupList; Production { - lhs: 327, - production: &[ParseType::N(327), ParseType::N(325)], + lhs: 332, + production: &[ParseType::N(332), ParseType::N(330)], }, - // 810 - InterfaceGroupGroupList: ; + // 840 - InterfaceGroupGroupList: ; Production { - lhs: 327, + lhs: 332, production: &[], }, - // 811 - InterfaceGroupGroup: InterfaceItem; + // 841 - InterfaceGroupGroup: InterfaceItem; Production { - lhs: 326, - production: &[ParseType::N(332)], + lhs: 331, + production: &[ParseType::N(337)], }, - // 812 - InterfaceGroupList: Attribute InterfaceGroupList; + // 842 - InterfaceGroupList: Attribute InterfaceGroupList; Production { - lhs: 328, - production: &[ParseType::N(328), ParseType::N(43)], + lhs: 333, + production: &[ParseType::N(333), ParseType::N(43)], }, - // 813 - InterfaceGroupList: ; + // 843 - InterfaceGroupList: ; Production { - lhs: 328, + lhs: 333, production: &[], }, - // 814 - InterfaceItem: LetDeclaration; + // 844 - InterfaceItem: LetDeclaration; Production { - lhs: 332, - production: &[ParseType::N(353)], + lhs: 337, + production: &[ParseType::N(358)], }, - // 815 - InterfaceItem: VarDeclaration; + // 845 - InterfaceItem: VarDeclaration; Production { - lhs: 332, - production: &[ParseType::N(595)], + lhs: 337, + production: &[ParseType::N(605)], }, - // 816 - InterfaceItem: LocalDeclaration; + // 846 - InterfaceItem: LocalDeclaration; Production { - lhs: 332, - production: &[ParseType::N(358)], + lhs: 337, + production: &[ParseType::N(363)], }, - // 817 - InterfaceItem: ModportDeclaration; + // 847 - InterfaceItem: ModportDeclaration; Production { - lhs: 332, - production: &[ParseType::N(375)], + lhs: 337, + production: &[ParseType::N(380)], }, - // 818 - InterfaceItem: InterfaceIfDeclaration; + // 848 - InterfaceItem: InterfaceIfDeclaration; Production { - lhs: 332, - production: &[ParseType::N(329)], + lhs: 337, + production: &[ParseType::N(334)], }, - // 819 - InterfaceItem: InterfaceForDeclaration; + // 849 - InterfaceItem: InterfaceForDeclaration; Production { - lhs: 332, - production: &[ParseType::N(323)], + lhs: 337, + production: &[ParseType::N(328)], }, - // 820 - InterfaceItem: TypeDefDeclaration; + // 850 - InterfaceItem: TypeDefDeclaration; Production { - lhs: 332, - production: &[ParseType::N(577)], + lhs: 337, + production: &[ParseType::N(587)], }, - // 821 - InterfaceItem: EnumDeclaration; + // 851 - InterfaceItem: EnumDeclaration; Production { - lhs: 332, - production: &[ParseType::N(137)], + lhs: 337, + production: &[ParseType::N(140)], }, - // 822 - InterfaceItem: StructUnionDeclaration; + // 852 - InterfaceItem: StructUnionDeclaration; Production { - lhs: 332, - production: &[ParseType::N(565)], + lhs: 337, + production: &[ParseType::N(574)], }, - // 823 - InterfaceItem: InterfaceNamedBlock; + // 853 - InterfaceItem: InterfaceNamedBlock; Production { - lhs: 332, - production: &[ParseType::N(333)], + lhs: 337, + production: &[ParseType::N(338)], }, - // 824 - InterfaceItem: FunctionDeclaration; + // 854 - InterfaceItem: FunctionDeclaration; Production { - lhs: 332, - production: &[ParseType::N(219)], + lhs: 337, + production: &[ParseType::N(222)], }, - // 825 - InterfaceItem: ImportDeclaration; + // 855 - InterfaceItem: ImportDeclaration; Production { - lhs: 332, - production: &[ParseType::N(265)], + lhs: 337, + production: &[ParseType::N(269)], }, - // 826 - InterfaceItem: InitialDeclaration; + // 856 - InterfaceItem: InitialDeclaration; Production { - lhs: 332, - production: &[ParseType::N(277)], + lhs: 337, + production: &[ParseType::N(281)], }, - // 827 - InterfaceItem: FinalDeclaration; + // 857 - InterfaceItem: FinalDeclaration; Production { - lhs: 332, - production: &[ParseType::N(202)], + lhs: 337, + production: &[ParseType::N(205)], }, - // 828 - PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier LBrace PackageDeclarationList /* Vec */ RBrace; + // 858 - PackageDeclaration: PackageDeclarationOpt /* Option */ Package Identifier PackageDeclarationOpt0 /* Option */ LBrace PackageDeclarationList /* Vec */ RBrace; Production { - lhs: 453, + lhs: 459, production: &[ - ParseType::N(489), - ParseType::N(454), - ParseType::N(343), - ParseType::N(239), - ParseType::N(452), - ParseType::N(455), + ParseType::N(496), + ParseType::N(460), + ParseType::N(348), + ParseType::N(462), + ParseType::N(243), + ParseType::N(458), + ParseType::N(461), ], }, - // 829 - PackageDeclarationList: PackageGroup PackageDeclarationList; + // 859 - PackageDeclarationList: PackageGroup PackageDeclarationList; Production { - lhs: 454, - production: &[ParseType::N(454), ParseType::N(456)], + lhs: 460, + production: &[ParseType::N(460), ParseType::N(463)], }, - // 830 - PackageDeclarationList: ; + // 860 - PackageDeclarationList: ; Production { - lhs: 454, + lhs: 460, production: &[], }, - // 831 - PackageDeclarationOpt: Pub; + // 861 - PackageDeclarationOpt0: WithGenericParameter; Production { - lhs: 455, - production: &[ParseType::N(480)], + lhs: 462, + production: &[ParseType::N(620)], }, - // 832 - PackageDeclarationOpt: ; + // 862 - PackageDeclarationOpt0: ; Production { - lhs: 455, + lhs: 462, production: &[], }, - // 833 - PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup; + // 863 - PackageDeclarationOpt: Pub; Production { - lhs: 456, - production: &[ParseType::N(457), ParseType::N(459)], + lhs: 461, + production: &[ParseType::N(487)], }, - // 834 - PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace; + // 864 - PackageDeclarationOpt: ; Production { - lhs: 457, - production: &[ParseType::N(489), ParseType::N(458), ParseType::N(343)], + lhs: 461, + production: &[], }, - // 835 - PackageGroupGroupList: PackageGroup PackageGroupGroupList; + // 865 - PackageGroup: PackageGroupList /* Vec */ PackageGroupGroup; Production { - lhs: 458, - production: &[ParseType::N(458), ParseType::N(456)], + lhs: 463, + production: &[ParseType::N(464), ParseType::N(466)], }, - // 836 - PackageGroupGroupList: ; + // 866 - PackageGroupGroup: LBrace PackageGroupGroupList /* Vec */ RBrace; Production { - lhs: 458, + lhs: 464, + production: &[ParseType::N(496), ParseType::N(465), ParseType::N(348)], + }, + // 867 - PackageGroupGroupList: PackageGroup PackageGroupGroupList; + Production { + lhs: 465, + production: &[ParseType::N(465), ParseType::N(463)], + }, + // 868 - PackageGroupGroupList: ; + Production { + lhs: 465, production: &[], }, - // 837 - PackageGroupGroup: PackageItem; + // 869 - PackageGroupGroup: PackageItem; Production { - lhs: 457, - production: &[ParseType::N(460)], + lhs: 464, + production: &[ParseType::N(467)], }, - // 838 - PackageGroupList: Attribute PackageGroupList; + // 870 - PackageGroupList: Attribute PackageGroupList; Production { - lhs: 459, - production: &[ParseType::N(459), ParseType::N(43)], + lhs: 466, + production: &[ParseType::N(466), ParseType::N(43)], }, - // 839 - PackageGroupList: ; + // 871 - PackageGroupList: ; Production { - lhs: 459, + lhs: 466, production: &[], }, - // 840 - PackageItem: VarDeclaration; + // 872 - PackageItem: VarDeclaration; Production { - lhs: 460, - production: &[ParseType::N(595)], + lhs: 467, + production: &[ParseType::N(605)], }, - // 841 - PackageItem: LocalDeclaration; + // 873 - PackageItem: LocalDeclaration; Production { - lhs: 460, - production: &[ParseType::N(358)], + lhs: 467, + production: &[ParseType::N(363)], }, - // 842 - PackageItem: TypeDefDeclaration; + // 874 - PackageItem: TypeDefDeclaration; Production { - lhs: 460, - production: &[ParseType::N(577)], + lhs: 467, + production: &[ParseType::N(587)], }, - // 843 - PackageItem: EnumDeclaration; + // 875 - PackageItem: EnumDeclaration; Production { - lhs: 460, - production: &[ParseType::N(137)], + lhs: 467, + production: &[ParseType::N(140)], }, - // 844 - PackageItem: StructUnionDeclaration; + // 876 - PackageItem: StructUnionDeclaration; Production { - lhs: 460, - production: &[ParseType::N(565)], + lhs: 467, + production: &[ParseType::N(574)], }, - // 845 - PackageItem: FunctionDeclaration; + // 877 - PackageItem: FunctionDeclaration; Production { - lhs: 460, - production: &[ParseType::N(219)], + lhs: 467, + production: &[ParseType::N(222)], }, - // 846 - PackageItem: ImportDeclaration; + // 878 - PackageItem: ImportDeclaration; Production { - lhs: 460, - production: &[ParseType::N(265)], + lhs: 467, + production: &[ParseType::N(269)], }, - // 847 - PackageItem: ExportDeclaration; + // 879 - PackageItem: ExportDeclaration; Production { - lhs: 460, - production: &[ParseType::N(155)], + lhs: 467, + production: &[ParseType::N(158)], }, - // 848 - PackageItem: InitialDeclaration; + // 880 - PackageItem: InitialDeclaration; Production { - lhs: 460, - production: &[ParseType::N(277)], + lhs: 467, + production: &[ParseType::N(281)], }, - // 849 - PackageItem: FinalDeclaration; + // 881 - PackageItem: FinalDeclaration; Production { - lhs: 460, - production: &[ParseType::N(202)], + lhs: 467, + production: &[ParseType::N(205)], }, - // 850 - EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent; + // 882 - EmbedDeclaration: Embed LParen Identifier RParen Identifier EmbedContent; Production { - lhs: 131, + lhs: 134, production: &[ - ParseType::N(128), - ParseType::N(239), - ParseType::N(495), - ParseType::N(239), - ParseType::N(349), - ParseType::N(127), + ParseType::N(131), + ParseType::N(243), + ParseType::N(502), + ParseType::N(243), + ParseType::N(354), + ParseType::N(130), ], }, - // 851 - EmbedContent: EmbedContentToken : crate::veryl_token::VerylToken ; + // 883 - EmbedContent: EmbedContentToken : crate::veryl_token::VerylToken ; Production { - lhs: 128, - production: &[ParseType::N(129)], + lhs: 131, + production: &[ParseType::N(132)], }, - // 852 - EmbedContentToken: LBraceTerm Push(1) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm Pop; + // 884 - EmbedContentToken: LBraceTerm Push(1) LBraceTerm LBraceTerm EmbedContentTokenList /* Vec */ RBraceTerm RBraceTerm RBraceTerm Pop; Production { - lhs: 129, + lhs: 132, production: &[ ParseType::Pop, - ParseType::N(490), - ParseType::N(490), - ParseType::N(490), - ParseType::N(130), - ParseType::N(344), - ParseType::N(344), + ParseType::N(497), + ParseType::N(497), + ParseType::N(497), + ParseType::N(133), + ParseType::N(349), + ParseType::N(349), ParseType::Push(1), - ParseType::N(344), + ParseType::N(349), ], }, - // 853 - EmbedContentTokenList: EmbedItem EmbedContentTokenList; + // 885 - EmbedContentTokenList: EmbedItem EmbedContentTokenList; Production { - lhs: 130, - production: &[ParseType::N(130), ParseType::N(132)], + lhs: 133, + production: &[ParseType::N(133), ParseType::N(135)], }, - // 854 - EmbedContentTokenList: ; + // 886 - EmbedContentTokenList: ; Production { - lhs: 130, + lhs: 133, production: &[], }, - // 855 - EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm; + // 887 - EmbedItem: LBraceTerm EmbedItemList /* Vec */ RBraceTerm; Production { - lhs: 132, - production: &[ParseType::N(490), ParseType::N(133), ParseType::N(344)], + lhs: 135, + production: &[ParseType::N(497), ParseType::N(136), ParseType::N(349)], }, - // 856 - EmbedItemList: EmbedItem EmbedItemList; + // 888 - EmbedItemList: EmbedItem EmbedItemList; Production { - lhs: 133, - production: &[ParseType::N(133), ParseType::N(132)], + lhs: 136, + production: &[ParseType::N(136), ParseType::N(135)], }, - // 857 - EmbedItemList: ; + // 889 - EmbedItemList: ; Production { - lhs: 133, + lhs: 136, production: &[], }, - // 858 - EmbedItem: AnyTerm; + // 890 - EmbedItem: AnyTerm; Production { - lhs: 132, + lhs: 135, production: &[ParseType::N(16)], }, - // 859 - IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon; + // 891 - IncludeDeclaration: Include LParen Identifier Comma StringLiteral RParen Semicolon; Production { - lhs: 273, + lhs: 277, production: &[ - ParseType::N(540), - ParseType::N(495), - ParseType::N(556), - ParseType::N(92), - ParseType::N(239), - ParseType::N(349), - ParseType::N(272), + ParseType::N(549), + ParseType::N(502), + ParseType::N(565), + ParseType::N(95), + ParseType::N(243), + ParseType::N(354), + ParseType::N(276), ], }, - // 860 - DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup; + // 892 - DescriptionGroup: DescriptionGroupList /* Vec */ DescriptionGroupGroup; Production { - lhs: 106, - production: &[ParseType::N(107), ParseType::N(109)], + lhs: 109, + production: &[ParseType::N(110), ParseType::N(112)], }, - // 861 - DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace; + // 893 - DescriptionGroupGroup: LBrace DescriptionGroupGroupList /* Vec */ RBrace; Production { - lhs: 107, - production: &[ParseType::N(489), ParseType::N(108), ParseType::N(343)], + lhs: 110, + production: &[ParseType::N(496), ParseType::N(111), ParseType::N(348)], }, - // 862 - DescriptionGroupGroupList: DescriptionGroup DescriptionGroupGroupList; + // 894 - DescriptionGroupGroupList: DescriptionGroup DescriptionGroupGroupList; Production { - lhs: 108, - production: &[ParseType::N(108), ParseType::N(106)], + lhs: 111, + production: &[ParseType::N(111), ParseType::N(109)], }, - // 863 - DescriptionGroupGroupList: ; + // 895 - DescriptionGroupGroupList: ; Production { - lhs: 108, + lhs: 111, production: &[], }, - // 864 - DescriptionGroupGroup: DescriptionItem; + // 896 - DescriptionGroupGroup: DescriptionItem; Production { - lhs: 107, - production: &[ParseType::N(110)], + lhs: 110, + production: &[ParseType::N(113)], }, - // 865 - DescriptionGroupList: Attribute DescriptionGroupList; + // 897 - DescriptionGroupList: Attribute DescriptionGroupList; Production { - lhs: 109, - production: &[ParseType::N(109), ParseType::N(43)], + lhs: 112, + production: &[ParseType::N(112), ParseType::N(43)], }, - // 866 - DescriptionGroupList: ; + // 898 - DescriptionGroupList: ; Production { - lhs: 109, + lhs: 112, production: &[], }, - // 867 - DescriptionItem: ModuleDeclaration; + // 899 - DescriptionItem: ModuleDeclaration; Production { - lhs: 110, - production: &[ParseType::N(386)], + lhs: 113, + production: &[ParseType::N(391)], }, - // 868 - DescriptionItem: InterfaceDeclaration; + // 900 - DescriptionItem: InterfaceDeclaration; Production { - lhs: 110, - production: &[ParseType::N(319)], + lhs: 113, + production: &[ParseType::N(323)], }, - // 869 - DescriptionItem: PackageDeclaration; + // 901 - DescriptionItem: PackageDeclaration; Production { - lhs: 110, - production: &[ParseType::N(453)], + lhs: 113, + production: &[ParseType::N(459)], }, - // 870 - DescriptionItem: ImportDeclaration; + // 902 - DescriptionItem: ImportDeclaration; Production { - lhs: 110, - production: &[ParseType::N(265)], + lhs: 113, + production: &[ParseType::N(269)], }, - // 871 - DescriptionItem: EmbedDeclaration; + // 903 - DescriptionItem: EmbedDeclaration; Production { - lhs: 110, - production: &[ParseType::N(131)], + lhs: 113, + production: &[ParseType::N(134)], }, - // 872 - DescriptionItem: IncludeDeclaration; + // 904 - DescriptionItem: IncludeDeclaration; Production { - lhs: 110, - production: &[ParseType::N(273)], + lhs: 113, + production: &[ParseType::N(277)], }, - // 873 - Veryl: Start VerylList /* Vec */; + // 905 - Veryl: Start VerylList /* Vec */; Production { - lhs: 601, - production: &[ParseType::N(602), ParseType::N(549)], + lhs: 611, + production: &[ParseType::N(612), ParseType::N(558)], }, - // 874 - VerylList: DescriptionGroup VerylList; + // 906 - VerylList: DescriptionGroup VerylList; Production { - lhs: 602, - production: &[ParseType::N(602), ParseType::N(106)], + lhs: 612, + production: &[ParseType::N(612), ParseType::N(109)], }, - // 875 - VerylList: ; + // 907 - VerylList: ; Production { - lhs: 602, + lhs: 612, production: &[], }, ]; @@ -19487,6 +21498,10 @@ static TOKENIZERS: Lazy> = Lazy::new(|| { "Embed", Tokenizer::build(TERMINALS, SCANNER_1.0, SCANNER_1.1).unwrap(), ), + ( + "Generic", + Tokenizer::build(TERMINALS, SCANNER_2.0, SCANNER_2.1).unwrap(), + ), ] }); @@ -19499,7 +21514,7 @@ where T: AsRef, { let mut llk_parser = LLKParser::new( - 601, + 611, LOOKAHEAD_AUTOMATA, PRODUCTIONS, TERMINAL_NAMES, diff --git a/crates/parser/src/stringifier.rs b/crates/parser/src/stringifier.rs index 50523441..cc4db6c4 100644 --- a/crates/parser/src/stringifier.rs +++ b/crates/parser/src/stringifier.rs @@ -1,9 +1,11 @@ +use crate::resource_table::StrId; use crate::veryl_token::VerylToken; use crate::veryl_walker::VerylWalker; #[derive(Default)] pub struct Stringifier { string: String, + ids: Vec, } impl Stringifier { @@ -14,11 +16,16 @@ impl Stringifier { pub fn as_str(&self) -> &str { &self.string } + + pub fn ids(&self) -> &[StrId] { + &self.ids + } } impl VerylWalker for Stringifier { /// Semantic action for non-terminal 'VerylToken' fn veryl_token(&mut self, arg: &VerylToken) { self.string.push_str(&arg.to_string()); + self.ids.push(arg.token.text); } } diff --git a/crates/parser/src/veryl_grammar_trait.rs b/crates/parser/src/veryl_grammar_trait.rs index b597d5e2..9bf8e08f 100644 --- a/crates/parser/src/veryl_grammar_trait.rs +++ b/crates/parser/src/veryl_grammar_trait.rs @@ -1,7 +1,7 @@ pub use crate::generated::veryl_grammar_trait::*; use paste::paste; -macro_rules! list_to_item { +macro_rules! list_group_to_item { ($x:ident) => { paste! { impl From<&[<$x List>]> for Vec<[<$x Item>]> { @@ -38,6 +38,25 @@ macro_rules! list_to_item { }; } +macro_rules! list_to_item { + ($x:ident) => { + paste! { + impl From<&[<$x List>]> for Vec<[<$x Item>]> { + fn from(x: &[<$x List>]) -> Self { + let mut ret = Vec::new(); + { + ret.push(x.[<$x:snake _item>].as_ref().clone()); + } + for x in &x.[<$x:snake _list_list>] { + ret.push(x.[<$x:snake _item>].as_ref().clone()); + } + ret + } + } + } + }; +} + macro_rules! group_to_item { ($x:ident) => { paste! { @@ -62,24 +81,42 @@ macro_rules! group_to_item { }; } -impl From<&AttributeList> for Vec { - fn from(x: &AttributeList) -> Self { +impl From<&ScopedIdentifier> for Vec> { + fn from(value: &ScopedIdentifier) -> Self { let mut ret = Vec::new(); - ret.push(x.attribute_item.as_ref().clone()); - for x in &x.attribute_list_list { - ret.push(x.attribute_item.as_ref().clone()); + match value.scoped_identifier_group.as_ref() { + ScopedIdentifierGroup::IdentifierScopedIdentifierOpt(ref x) => { + if let Some(ref x) = x.scoped_identifier_opt { + ret.push(Some(x.with_generic_argument.as_ref().clone())); + } else { + ret.push(None); + } + } + ScopedIdentifierGroup::DollarIdentifier(_) => { + ret.push(None); + } + } + for x in &value.scoped_identifier_list { + if let Some(ref x) = x.scoped_identifier_opt0 { + ret.push(Some(x.with_generic_argument.as_ref().clone())); + } else { + ret.push(None); + } } ret } } -list_to_item!(Modport); -list_to_item!(Enum); -list_to_item!(StructUnion); -list_to_item!(InstParameter); -list_to_item!(InstPort); -list_to_item!(WithParameter); -list_to_item!(PortDeclaration); +list_group_to_item!(Modport); +list_group_to_item!(Enum); +list_group_to_item!(StructUnion); +list_group_to_item!(InstParameter); +list_group_to_item!(InstPort); +list_group_to_item!(WithParameter); +list_group_to_item!(PortDeclaration); +list_to_item!(WithGenericParameter); +list_to_item!(WithGenericArgument); +list_to_item!(Attribute); group_to_item!(Module); group_to_item!(Interface); group_to_item!(Package); diff --git a/crates/parser/src/veryl_token.rs b/crates/parser/src/veryl_token.rs index 29363127..d10b943d 100644 --- a/crates/parser/src/veryl_token.rs +++ b/crates/parser/src/veryl_token.rs @@ -106,7 +106,7 @@ impl From for miette::SourceSpan { } } -#[derive(Debug, Clone, Copy)] +#[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct TokenRange { pub beg: Token, pub end: Token, @@ -383,7 +383,9 @@ impl fmt::Display for VerylToken { impl ScopedIdentifier { pub fn identifier(&self) -> &VerylToken { match &*self.scoped_identifier_group { - ScopedIdentifierGroup::Identifier(x) => &x.identifier.identifier_token, + ScopedIdentifierGroup::IdentifierScopedIdentifierOpt(x) => { + &x.identifier.identifier_token + } ScopedIdentifierGroup::DollarIdentifier(x) => { &x.dollar_identifier.dollar_identifier_token } @@ -511,6 +513,7 @@ token_with_comments!(AllBit); token_with_comments!(Colon); token_with_comments!(ColonColon); +token_with_comments!(ColonColonLAngle); token_with_comments!(Comma); token_with_comments!(DotDot); token_with_comments!(DotDotEqu); diff --git a/crates/parser/src/veryl_walker.rs b/crates/parser/src/veryl_walker.rs index 43a64ee2..7b680b86 100644 --- a/crates/parser/src/veryl_walker.rs +++ b/crates/parser/src/veryl_walker.rs @@ -181,6 +181,13 @@ pub trait VerylWalker { after!(self, colon_colon, arg); } + /// Semantic action for non-terminal 'ColonColonLAngle' + fn colon_colon_l_angle(&mut self, arg: &ColonColonLAngle) { + before!(self, colon_colon_l_angle, arg); + self.veryl_token(&arg.colon_colon_l_angle_token); + after!(self, colon_colon_l_angle, arg); + } + /// Semantic action for non-terminal 'Comma' fn comma(&mut self, arg: &Comma) { before!(self, comma, arg); @@ -828,7 +835,12 @@ pub trait VerylWalker { fn scoped_identifier(&mut self, arg: &ScopedIdentifier) { before!(self, scoped_identifier, arg); match &*arg.scoped_identifier_group { - ScopedIdentifierGroup::Identifier(x) => self.identifier(&x.identifier), + ScopedIdentifierGroup::IdentifierScopedIdentifierOpt(x) => { + self.identifier(&x.identifier); + if let Some(ref x) = x.scoped_identifier_opt { + self.with_generic_argument(&x.with_generic_argument); + } + } ScopedIdentifierGroup::DollarIdentifier(x) => { self.dollar_identifier(&x.dollar_identifier) } @@ -836,6 +848,9 @@ pub trait VerylWalker { for x in &arg.scoped_identifier_list { self.colon_colon(&x.colon_colon); self.identifier(&x.identifier); + if let Some(ref x) = x.scoped_identifier_opt0 { + self.with_generic_argument(&x.with_generic_argument); + } } after!(self, scoped_identifier, arg); } @@ -1866,6 +1881,9 @@ pub trait VerylWalker { before!(self, struct_union_declaration, arg); self.struct_union(&arg.struct_union); self.identifier(&arg.identifier); + if let Some(ref x) = arg.struct_union_declaration_opt { + self.with_generic_parameter(&x.with_generic_parameter); + } self.l_brace(&arg.l_brace); self.struct_union_list(&arg.struct_union_list); self.r_brace(&arg.r_brace); @@ -2142,6 +2160,73 @@ pub trait VerylWalker { after!(self, with_parameter_item, arg); } + /// Semantic action for non-terminal 'WithGenericParameter' + fn with_generic_parameter(&mut self, arg: &WithGenericParameter) { + before!(self, with_generic_parameter, arg); + self.colon_colon_l_angle(&arg.colon_colon_l_angle); + self.with_generic_parameter_list(&arg.with_generic_parameter_list); + self.r_angle(&arg.r_angle); + after!(self, with_generic_parameter, arg); + } + + /// Semantic action for non-terminal 'WithGenericParameterList' + fn with_generic_parameter_list(&mut self, arg: &WithGenericParameterList) { + before!(self, with_generic_parameter_list, arg); + self.with_generic_parameter_item(&arg.with_generic_parameter_item); + for x in &arg.with_generic_parameter_list_list { + self.comma(&x.comma); + self.with_generic_parameter_item(&x.with_generic_parameter_item); + } + if let Some(ref x) = arg.with_generic_parameter_list_opt { + self.comma(&x.comma); + } + after!(self, with_generic_parameter_list, arg); + } + + /// Semantic action for non-terminal 'WithGenericParameterItem' + fn with_generic_parameter_item(&mut self, arg: &WithGenericParameterItem) { + before!(self, with_generic_parameter_item, arg); + self.identifier(&arg.identifier); + after!(self, with_generic_parameter_item, arg); + } + + /// Semantic action for non-terminal 'WithGenericArgument' + fn with_generic_argument(&mut self, arg: &WithGenericArgument) { + before!(self, with_generic_argument, arg); + self.colon_colon_l_angle(&arg.colon_colon_l_angle); + self.with_generic_argument_list(&arg.with_generic_argument_list); + self.r_angle(&arg.r_angle); + after!(self, with_generic_argument, arg); + } + + /// Semantic action for non-terminal 'WithGenericArgumentList' + fn with_generic_argument_list(&mut self, arg: &WithGenericArgumentList) { + before!(self, with_generic_argument_list, arg); + self.with_generic_argument_item(&arg.with_generic_argument_item); + for x in &arg.with_generic_argument_list_list { + self.comma(&x.comma); + self.with_generic_argument_item(&x.with_generic_argument_item); + } + if let Some(ref x) = arg.with_generic_argument_list_opt { + self.comma(&x.comma); + } + after!(self, with_generic_argument_list, arg); + } + + /// Semantic action for non-terminal 'WithGenericArgumentItem' + fn with_generic_argument_item(&mut self, arg: &WithGenericArgumentItem) { + before!(self, with_generic_argument_item, arg); + match arg { + WithGenericArgumentItem::ScopedIdentifier(x) => { + self.scoped_identifier(&x.scoped_identifier); + } + WithGenericArgumentItem::Number(x) => { + self.number(&x.number); + } + } + after!(self, with_generic_argument_item, arg); + } + /// Semantic action for non-terminal 'PortDeclaration' fn port_declaration(&mut self, arg: &PortDeclaration) { before!(self, port_declaration, arg); @@ -2225,9 +2310,12 @@ pub trait VerylWalker { self.function(&arg.function); self.identifier(&arg.identifier); if let Some(ref x) = arg.function_declaration_opt { - self.port_declaration(&x.port_declaration); + self.with_generic_parameter(&x.with_generic_parameter); } if let Some(ref x) = arg.function_declaration_opt0 { + self.port_declaration(&x.port_declaration); + } + if let Some(ref x) = arg.function_declaration_opt1 { self.minus_g_t(&x.minus_g_t); self.scalar_type(&x.scalar_type); } @@ -2289,9 +2377,12 @@ pub trait VerylWalker { self.module(&arg.module); self.identifier(&arg.identifier); if let Some(ref x) = arg.module_declaration_opt0 { - self.with_parameter(&x.with_parameter); + self.with_generic_parameter(&x.with_generic_parameter); } if let Some(ref x) = arg.module_declaration_opt1 { + self.with_parameter(&x.with_parameter); + } + if let Some(ref x) = arg.module_declaration_opt2 { self.port_declaration(&x.port_declaration); } self.l_brace(&arg.l_brace); @@ -2430,6 +2521,9 @@ pub trait VerylWalker { self.interface(&arg.interface); self.identifier(&arg.identifier); if let Some(ref x) = arg.interface_declaration_opt0 { + self.with_generic_parameter(&x.with_generic_parameter); + } + if let Some(ref x) = arg.interface_declaration_opt1 { self.with_parameter(&x.with_parameter); } self.l_brace(&arg.l_brace); @@ -2568,6 +2662,9 @@ pub trait VerylWalker { } self.package(&arg.package); self.identifier(&arg.identifier); + if let Some(ref x) = arg.package_declaration_opt0 { + self.with_generic_parameter(&x.with_generic_parameter); + } self.l_brace(&arg.l_brace); for x in &arg.package_declaration_list { self.package_group(&x.package_group); diff --git a/crates/parser/veryl.par b/crates/parser/veryl.par index c8da2b7c..26fc83c3 100644 --- a/crates/parser/veryl.par +++ b/crates/parser/veryl.par @@ -10,6 +10,9 @@ %auto_ws_off } +%scanner Generic { +} + %% // ---------------------------------------------------------------------------- @@ -18,114 +21,115 @@ // Longest match should be first -CommentsTerm : "(?:(?:(?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))\s*)+" : Token; -StringLiteralTerm : "\u{0022}(?:\\[\u{0022}\\/bfnrt]|u[0-9a-fA-F]{4}|[^\u{0022}\\\u0000-\u001F])*\u{0022}": Token; -ExponentTerm : /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*[eE][+-]?[0-9]+(?:_[0-9]+)*/ : Token; -FixedPointTerm : /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*/ : Token; -BasedTerm : /(?:[0-9]+(?:_[0-9]+)*)?'[bodh][0-9a-fA-FxzXZ]+(?:_[0-9a-fA-FxzXZ]+)*/ : Token; -AllBitTerm : /(?:[0-9]+(?:_[0-9]+)*)?'[01xzXZ]/ : Token; -BaseLessTerm : /[0-9]+(?:_[0-9]+)*/ : Token; -MinusColonTerm : '-:' : Token; -MinusGTTerm : '->' : Token; -PlusColonTerm : '+:' : Token; -AssignmentOperatorTerm: "\+=|-=|\*=|/=|%=|&=|\|=|\^=|<<=|>>=|<<<=|>>>=" : Token; -Operator11Term : "\*\*" : Token; -Operator10Term : "/|%" : Token; -Operator09Term : "\+|-" : Token; -Operator08Term : "<<<|>>>|<<|>>" : Token; -Operator07Term : "<=|>=|<:|>:" : Token; -Operator06Term : "===|==\?|!==|!=\?|==|!=" : Token; -Operator02Term : "&&" : Token; -Operator01Term : "\|\|" : Token; -Operator05Term : "&" : Token; -Operator04Term : "\^~|\^|~\^" : Token; -Operator03Term : "\|" : Token; -UnaryOperatorTerm : "~&|~\||!|~" : Token; -ColonColonTerm : '::' : Token; -ColonTerm : ':' : Token; -CommaTerm : ',' : Token; -DotDotEquTerm : '..=' : Token; -DotDotTerm : '..' : Token; -DotTerm : '.' : Token; -EquTerm : '=' : Token; -HashTerm : '#' : Token; -LAngleTerm : '<' : Token; -QuoteLBraceTerm : "'\{" : Token; -LBraceTerm : '{' : Token; -LBracketTerm : '[' : Token; -LParenTerm : '(' : Token; -RAngleTerm : '>' : Token; -RBraceTerm : '}' : Token; -RBracketTerm : ']' : Token; -RParenTerm : ')' : Token; -SemicolonTerm : ';' : Token; -StarTerm : '*' : Token; -AlwaysCombTerm : /(?-u:\b)always_comb(?-u:\b)/ : Token; -AlwaysFfTerm : /(?-u:\b)always_ff(?-u:\b)/ : Token; -AssignTerm : /(?-u:\b)assign(?-u:\b)/ : Token; -AsTerm : /(?-u:\b)as(?-u:\b)/ : Token; -BitTerm : /(?-u:\b)bit(?-u:\b)/ : Token; -CaseTerm : /(?-u:\b)case(?-u:\b)/ : Token; -ClockTerm : /(?-u:\b)clock(?-u:\b)/ : Token; -ClockPosedgeTerm : /(?-u:\b)clock_posedge(?-u:\b)/ : Token; -ClockNegedgeTerm : /(?-u:\b)clock_negedge(?-u:\b)/ : Token; -DefaultTerm : /(?-u:\b)default(?-u:\b)/ : Token; -ElseTerm : /(?-u:\b)else(?-u:\b)/ : Token; -EmbedTerm : /(?-u:\b)embed(?-u:\b)/ : Token; -EnumTerm : /(?-u:\b)enum(?-u:\b)/ : Token; -ExportTerm : /(?-u:\b)export(?-u:\b)/ : Token; -F32Term : /(?-u:\b)f32(?-u:\b)/ : Token; -F64Term : /(?-u:\b)f64(?-u:\b)/ : Token; -FinalTerm : /(?-u:\b)final(?-u:\b)/ : Token; -ForTerm : /(?-u:\b)for(?-u:\b)/ : Token; -FunctionTerm : /(?-u:\b)function(?-u:\b)/ : Token; -I32Term : /(?-u:\b)i32(?-u:\b)/ : Token; -I64Term : /(?-u:\b)i64(?-u:\b)/ : Token; -IfResetTerm : /(?-u:\b)if_reset(?-u:\b)/ : Token; -IfTerm : /(?-u:\b)if(?-u:\b)/ : Token; -ImportTerm : /(?-u:\b)import(?-u:\b)/ : Token; -IncludeTerm : /(?-u:\b)include(?-u:\b)/ : Token; -InitialTerm : /(?-u:\b)initial(?-u:\b)/ : Token; -InoutTerm : /(?-u:\b)inout(?-u:\b)/ : Token; -InputTerm : /(?-u:\b)input(?-u:\b)/ : Token; -InsideTerm : /(?-u:\b)inside(?-u:\b)/ : Token; -InstTerm : /(?-u:\b)inst(?-u:\b)/ : Token; -InterfaceTerm : /(?-u:\b)interface(?-u:\b)/ : Token; -InTerm : /(?-u:\b)in(?-u:\b)/ : Token; -LetTerm : /(?-u:\b)let(?-u:\b)/ : Token; -LocalTerm : /(?-u:\b)local(?-u:\b)/ : Token; -LogicTerm : /(?-u:\b)logic(?-u:\b)/ : Token; -LsbTerm : /(?-u:\b)lsb(?-u:\b)/ : Token; -ModportTerm : /(?-u:\b)modport(?-u:\b)/ : Token; -ModuleTerm : /(?-u:\b)module(?-u:\b)/ : Token; -MsbTerm : /(?-u:\b)msb(?-u:\b)/ : Token; -OutputTerm : /(?-u:\b)output(?-u:\b)/ : Token; -OutsideTerm : /(?-u:\b)outside(?-u:\b)/ : Token; -PackageTerm : /(?-u:\b)package(?-u:\b)/ : Token; -ParamTerm : /(?-u:\b)param(?-u:\b)/ : Token; -PubTerm : /(?-u:\b)pub(?-u:\b)/ : Token; -RefTerm : /(?-u:\b)ref(?-u:\b)/ : Token; -RepeatTerm : /(?-u:\b)repeat(?-u:\b)/ : Token; -ResetTerm : /(?-u:\b)reset(?-u:\b)/ : Token; -ResetAsyncHighTerm : /(?-u:\b)reset_async_high(?-u:\b)/ : Token; -ResetAsyncLowTerm : /(?-u:\b)reset_async_low(?-u:\b)/ : Token; -ResetSyncHighTerm : /(?-u:\b)reset_sync_high(?-u:\b)/ : Token; -ResetSyncLowTerm : /(?-u:\b)reset_sync_low(?-u:\b)/ : Token; -ReturnTerm : /(?-u:\b)return(?-u:\b)/ : Token; -BreakTerm : /(?-u:\b)break(?-u:\b)/ : Token; -SignedTerm : /(?-u:\b)signed(?-u:\b)/ : Token; -StepTerm : /(?-u:\b)step(?-u:\b)/ : Token; -StringTerm : /(?-u:\b)string(?-u:\b)/ : Token; -StructTerm : /(?-u:\b)struct(?-u:\b)/ : Token; -TriTerm : /(?-u:\b)tri(?-u:\b)/ : Token; -TypeTerm : /(?-u:\b)type(?-u:\b)/ : Token; -U32Term : /(?-u:\b)u32(?-u:\b)/ : Token; -U64Term : /(?-u:\b)u64(?-u:\b)/ : Token; -UnionTerm : /(?-u:\b)union(?-u:\b)/ : Token; -VarTerm : /(?-u:\b)var(?-u:\b)/ : Token; -DollarIdentifierTerm : /\$[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; -IdentifierTerm : /[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; -AnyTerm : /[^{}]*/ : Token; +CommentsTerm : "(?:(?:(?://.*(?:\r\n|\r|\n|$))|(?:(?ms)/\u{2a}.*?\u{2a}/))\s*)+" : Token; +StringLiteralTerm : "\u{0022}(?:\\[\u{0022}\\/bfnrt]|u[0-9a-fA-F]{4}|[^\u{0022}\\\u0000-\u001F])*\u{0022}": Token; +ExponentTerm : /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*[eE][+-]?[0-9]+(?:_[0-9]+)*/ : Token; +FixedPointTerm : /[0-9]+(?:_[0-9]+)*\.[0-9]+(?:_[0-9]+)*/ : Token; +BasedTerm : /(?:[0-9]+(?:_[0-9]+)*)?'[bodh][0-9a-fA-FxzXZ]+(?:_[0-9a-fA-FxzXZ]+)*/ : Token; +AllBitTerm : /(?:[0-9]+(?:_[0-9]+)*)?'[01xzXZ]/ : Token; +BaseLessTerm : /[0-9]+(?:_[0-9]+)*/ : Token; +MinusColonTerm : '-:' : Token; +MinusGTTerm : '->' : Token; +PlusColonTerm : '+:' : Token; +AssignmentOperatorTerm: "\+=|-=|\*=|/=|%=|&=|\|=|\^=|<<=|>>=|<<<=|>>>=" : Token; +Operator11Term : "\*\*" : Token; +Operator10Term : "/|%" : Token; +Operator09Term : "\+|-" : Token; +Operator08Term : "<<<|>>>|<<|>>" : Token; +Operator07Term : "<=|>=|<:|>:" : Token; +Operator06Term : "===|==\?|!==|!=\?|==|!=" : Token; +Operator02Term : "&&" : Token; +Operator01Term : "\|\|" : Token; +Operator05Term : "&" : Token; +Operator04Term : "\^~|\^|~\^" : Token; +Operator03Term : "\|" : Token; +UnaryOperatorTerm : "~&|~\||!|~" : Token; +ColonColonLAngleTerm : '::<' : Token; +ColonColonTerm : '::' : Token; +ColonTerm : ':' : Token; +CommaTerm : ',' : Token; +DotDotEquTerm : '..=' : Token; +DotDotTerm : '..' : Token; +DotTerm : '.' : Token; +EquTerm : '=' : Token; +HashTerm : '#' : Token; +LAngleTerm : '<' : Token; +QuoteLBraceTerm : "'\{" : Token; +LBraceTerm : '{' : Token; +LBracketTerm : '[' : Token; +LParenTerm : '(' : Token; +RAngleTerm : '>' : Token; +RBraceTerm : '}' : Token; +RBracketTerm : ']' : Token; +RParenTerm : ')' : Token; +SemicolonTerm : ';' : Token; +StarTerm : '*' : Token; +AlwaysCombTerm : /(?-u:\b)always_comb(?-u:\b)/ : Token; +AlwaysFfTerm : /(?-u:\b)always_ff(?-u:\b)/ : Token; +AssignTerm : /(?-u:\b)assign(?-u:\b)/ : Token; +AsTerm : /(?-u:\b)as(?-u:\b)/ : Token; +BitTerm : /(?-u:\b)bit(?-u:\b)/ : Token; +CaseTerm : /(?-u:\b)case(?-u:\b)/ : Token; +ClockTerm : /(?-u:\b)clock(?-u:\b)/ : Token; +ClockPosedgeTerm : /(?-u:\b)clock_posedge(?-u:\b)/ : Token; +ClockNegedgeTerm : /(?-u:\b)clock_negedge(?-u:\b)/ : Token; +DefaultTerm : /(?-u:\b)default(?-u:\b)/ : Token; +ElseTerm : /(?-u:\b)else(?-u:\b)/ : Token; +EmbedTerm : /(?-u:\b)embed(?-u:\b)/ : Token; +EnumTerm : /(?-u:\b)enum(?-u:\b)/ : Token; +ExportTerm : /(?-u:\b)export(?-u:\b)/ : Token; +F32Term : /(?-u:\b)f32(?-u:\b)/ : Token; +F64Term : /(?-u:\b)f64(?-u:\b)/ : Token; +FinalTerm : /(?-u:\b)final(?-u:\b)/ : Token; +ForTerm : /(?-u:\b)for(?-u:\b)/ : Token; +FunctionTerm : /(?-u:\b)function(?-u:\b)/ : Token; +I32Term : /(?-u:\b)i32(?-u:\b)/ : Token; +I64Term : /(?-u:\b)i64(?-u:\b)/ : Token; +IfResetTerm : /(?-u:\b)if_reset(?-u:\b)/ : Token; +IfTerm : /(?-u:\b)if(?-u:\b)/ : Token; +ImportTerm : /(?-u:\b)import(?-u:\b)/ : Token; +IncludeTerm : /(?-u:\b)include(?-u:\b)/ : Token; +InitialTerm : /(?-u:\b)initial(?-u:\b)/ : Token; +InoutTerm : /(?-u:\b)inout(?-u:\b)/ : Token; +InputTerm : /(?-u:\b)input(?-u:\b)/ : Token; +InsideTerm : /(?-u:\b)inside(?-u:\b)/ : Token; +InstTerm : /(?-u:\b)inst(?-u:\b)/ : Token; +InterfaceTerm : /(?-u:\b)interface(?-u:\b)/ : Token; +InTerm : /(?-u:\b)in(?-u:\b)/ : Token; +LetTerm : /(?-u:\b)let(?-u:\b)/ : Token; +LocalTerm : /(?-u:\b)local(?-u:\b)/ : Token; +LogicTerm : /(?-u:\b)logic(?-u:\b)/ : Token; +LsbTerm : /(?-u:\b)lsb(?-u:\b)/ : Token; +ModportTerm : /(?-u:\b)modport(?-u:\b)/ : Token; +ModuleTerm : /(?-u:\b)module(?-u:\b)/ : Token; +MsbTerm : /(?-u:\b)msb(?-u:\b)/ : Token; +OutputTerm : /(?-u:\b)output(?-u:\b)/ : Token; +OutsideTerm : /(?-u:\b)outside(?-u:\b)/ : Token; +PackageTerm : /(?-u:\b)package(?-u:\b)/ : Token; +ParamTerm : /(?-u:\b)param(?-u:\b)/ : Token; +PubTerm : /(?-u:\b)pub(?-u:\b)/ : Token; +RefTerm : /(?-u:\b)ref(?-u:\b)/ : Token; +RepeatTerm : /(?-u:\b)repeat(?-u:\b)/ : Token; +ResetTerm : /(?-u:\b)reset(?-u:\b)/ : Token; +ResetAsyncHighTerm : /(?-u:\b)reset_async_high(?-u:\b)/ : Token; +ResetAsyncLowTerm : /(?-u:\b)reset_async_low(?-u:\b)/ : Token; +ResetSyncHighTerm : /(?-u:\b)reset_sync_high(?-u:\b)/ : Token; +ResetSyncLowTerm : /(?-u:\b)reset_sync_low(?-u:\b)/ : Token; +ReturnTerm : /(?-u:\b)return(?-u:\b)/ : Token; +BreakTerm : /(?-u:\b)break(?-u:\b)/ : Token; +SignedTerm : /(?-u:\b)signed(?-u:\b)/ : Token; +StepTerm : /(?-u:\b)step(?-u:\b)/ : Token; +StringTerm : /(?-u:\b)string(?-u:\b)/ : Token; +StructTerm : /(?-u:\b)struct(?-u:\b)/ : Token; +TriTerm : /(?-u:\b)tri(?-u:\b)/ : Token; +TypeTerm : /(?-u:\b)type(?-u:\b)/ : Token; +U32Term : /(?-u:\b)u32(?-u:\b)/ : Token; +U64Term : /(?-u:\b)u64(?-u:\b)/ : Token; +UnionTerm : /(?-u:\b)union(?-u:\b)/ : Token; +VarTerm : /(?-u:\b)var(?-u:\b)/ : Token; +DollarIdentifierTerm : /\$[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; +IdentifierTerm : /[a-zA-Z_][0-9a-zA-Z_$]*/ : Token; +AnyTerm : < Embed>/[^{}]*/ : Token; // ---------------------------------------------------------------------------- // Token @@ -157,28 +161,29 @@ Operator10Token : Operator10Term : Token Comments; Operator11Token : Operator11Term : Token Comments; UnaryOperatorToken : UnaryOperatorTerm : Token Comments; -ColonToken : ColonTerm : Token Comments; -ColonColonToken : ColonColonTerm : Token Comments; -CommaToken : CommaTerm : Token Comments; -DotDotToken : DotDotTerm : Token Comments; -DotDotEquToken : DotDotEquTerm : Token Comments; -DotToken : DotTerm : Token Comments; -EquToken : EquTerm : Token Comments; -HashToken : HashTerm : Token Comments; -QuoteLBraceToken : QuoteLBraceTerm : Token Comments; -LAngleToken : LAngleTerm : Token Comments; -LBraceToken : LBraceTerm : Token Comments; -LBracketToken : LBracketTerm : Token Comments; -LParenToken : LParenTerm : Token Comments; -MinusColonToken : MinusColonTerm : Token Comments; -MinusGTToken : MinusGTTerm : Token Comments; -PlusColonToken : PlusColonTerm : Token Comments; -RAngleToken : RAngleTerm : Token Comments; -RBraceToken : RBraceTerm : Token Comments; -RBracketToken : RBracketTerm : Token Comments; -RParenToken : RParenTerm : Token Comments; -SemicolonToken : SemicolonTerm : Token Comments; -StarToken : StarTerm : Token Comments; +ColonToken : ColonTerm : Token Comments; +ColonColonLAngleToken: ColonColonLAngleTerm: Token Comments; +ColonColonToken : ColonColonTerm : Token Comments; +CommaToken : CommaTerm : Token Comments; +DotDotToken : DotDotTerm : Token Comments; +DotDotEquToken : DotDotEquTerm : Token Comments; +DotToken : DotTerm : Token Comments; +EquToken : EquTerm : Token Comments; +HashToken : HashTerm : Token Comments; +QuoteLBraceToken : QuoteLBraceTerm : Token Comments; +LAngleToken : LAngleTerm : Token Comments; +LBraceToken : LBraceTerm : Token Comments; +LBracketToken : LBracketTerm : Token Comments; +LParenToken : LParenTerm : Token Comments; +MinusColonToken : MinusColonTerm : Token Comments; +MinusGTToken : MinusGTTerm : Token Comments; +PlusColonToken : PlusColonTerm : Token Comments; +RAngleToken : RAngleTerm : Token Comments; +RBraceToken : RBraceTerm : Token Comments; +RBracketToken : RBracketTerm : Token Comments; +RParenToken : RParenTerm : Token Comments; +SemicolonToken : SemicolonTerm : Token Comments; +StarToken : StarTerm : Token Comments; AlwaysCombToken : AlwaysCombTerm : Token Comments; AlwaysFfToken : AlwaysFfTerm : Token Comments; @@ -280,28 +285,29 @@ Operator11 : Operator11Token : VerylToken; UnaryOperator : UnaryOperatorToken : VerylToken; // Symbol -Colon : ColonToken : VerylToken; -ColonColon : ColonColonToken : VerylToken; -Comma : CommaToken : VerylToken; -DotDot : DotDotToken : VerylToken; -DotDotEqu : DotDotEquToken : VerylToken; -Dot : DotToken : VerylToken; -Equ : EquToken : VerylToken; -Hash : HashToken : VerylToken; -QuoteLBrace : QuoteLBraceToken : VerylToken; -LAngle : LAngleToken : VerylToken; -LBrace : LBraceToken : VerylToken; -LBracket : LBracketToken : VerylToken; -LParen : LParenToken : VerylToken; -MinusColon : MinusColonToken : VerylToken; -MinusGT : MinusGTToken : VerylToken; -PlusColon : PlusColonToken : VerylToken; -RAngle : RAngleToken : VerylToken; -RBrace : RBraceToken : VerylToken; -RBracket : RBracketToken : VerylToken; -RParen : RParenToken : VerylToken; -Semicolon : SemicolonToken : VerylToken; -Star : StarToken : VerylToken; +Colon : ColonToken : VerylToken; +ColonColonLAngle: ColonColonLAngleToken: VerylToken; +ColonColon : ColonColonToken : VerylToken; +Comma : CommaToken : VerylToken; +DotDot : DotDotToken : VerylToken; +DotDotEqu : DotDotEquToken : VerylToken; +Dot : DotToken : VerylToken; +Equ : EquToken : VerylToken; +Hash : HashToken : VerylToken; +QuoteLBrace : QuoteLBraceToken : VerylToken; +LAngle : LAngleToken : VerylToken; +LBrace : LBraceToken : VerylToken; +LBracket : LBracketToken : VerylToken; +LParen : LParenToken : VerylToken; +MinusColon : MinusColonToken : VerylToken; +MinusGT : MinusGTToken : VerylToken; +PlusColon : PlusColonToken : VerylToken; +RAngle : RAngleToken : VerylToken; +RBrace : RBraceToken : VerylToken; +RBracket : RBracketToken : VerylToken; +RParen : RParenToken : VerylToken; +Semicolon : SemicolonToken : VerylToken; +Star : StarToken : VerylToken; // Keyword AlwaysComb : AlwaysCombToken : VerylToken; @@ -394,7 +400,7 @@ RealNumber: FixedPoint // ---------------------------------------------------------------------------- HierarchicalIdentifier: Identifier { Select } { Dot Identifier { Select } }; -ScopedIdentifier : ( DollarIdentifier | Identifier ) { ColonColon Identifier }; +ScopedIdentifier : ( DollarIdentifier | Identifier [ WithGenericArgument ] ) { ColonColon Identifier [ WithGenericArgument ] }; ExpressionIdentifier : ScopedIdentifier { Select } { Dot Identifier { Select } }; // ---------------------------------------------------------------------------- @@ -591,7 +597,7 @@ EnumItem: Identifier [ Equ Expression ]; StructUnion: Struct | Union; -StructUnionDeclaration: StructUnion Identifier LBrace StructUnionList RBrace; +StructUnionDeclaration: StructUnion Identifier [ WithGenericParameter ] LBrace StructUnionList RBrace; StructUnionList: StructUnionGroup { Comma StructUnionGroup } [ Comma ]; @@ -635,6 +641,28 @@ WithParameterGroup: { Attribute } ( LBrace WithParameterList RBrace | WithParame WithParameterItem: ( Param | Local ) Identifier Colon ( ArrayType Equ Expression | Type Equ TypeExpression ); +// ---------------------------------------------------------------------------- +// WithGenericParameter +// ---------------------------------------------------------------------------- + +WithGenericParameter: ColonColonLAngle WithGenericParameterList RAngle; + +WithGenericParameterList: WithGenericParameterItem { Comma WithGenericParameterItem } [ Comma ]; + +WithGenericParameterItem: Identifier; + +// ---------------------------------------------------------------------------- +// WithGenericArgument +// ---------------------------------------------------------------------------- + +WithGenericArgument: ColonColonLAngle %push(Generic) WithGenericArgumentList RAngle %pop(); + +WithGenericArgumentList: WithGenericArgumentItem { Comma WithGenericArgumentItem } [ Comma ]; + +WithGenericArgumentItem: ScopedIdentifier + | Number + ; + // ---------------------------------------------------------------------------- // PortDeclaration // ---------------------------------------------------------------------------- @@ -658,7 +686,7 @@ Direction: Input // Function // ---------------------------------------------------------------------------- -FunctionDeclaration: Function Identifier [ PortDeclaration ] [ MinusGT ScalarType ] LBrace { FunctionItem } RBrace; +FunctionDeclaration: Function Identifier [ WithGenericParameter ] [ PortDeclaration ] [ MinusGT ScalarType ] LBrace { FunctionItem } RBrace; FunctionItem: VarDeclaration | Statement @@ -676,7 +704,7 @@ ExportDeclaration: Export ( Star | ScopedIdentifier [ ColonColon Star ] ) Semico // Module // ---------------------------------------------------------------------------- -ModuleDeclaration: [ Pub ] Module Identifier [ WithParameter ] [ PortDeclaration ] LBrace { ModuleGroup } RBrace; +ModuleDeclaration: [ Pub ] Module Identifier [ WithGenericParameter ] [ WithParameter ] [ PortDeclaration ] LBrace { ModuleGroup } RBrace; ModuleIfDeclaration: If Expression ModuleNamedBlock { Else If Expression ModuleOptionalNamedBlock } [ Else ModuleOptionalNamedBlock ]; @@ -711,7 +739,7 @@ ModuleItem: LetDeclaration // Interface // ---------------------------------------------------------------------------- -InterfaceDeclaration: [ Pub ] Interface Identifier [ WithParameter ] LBrace { InterfaceGroup } RBrace; +InterfaceDeclaration: [ Pub ] Interface Identifier [ WithGenericParameter ] [ WithParameter ] LBrace { InterfaceGroup } RBrace; InterfaceIfDeclaration: If Expression InterfaceNamedBlock { Else If Expression InterfaceOptionalNamedBlock } [ Else InterfaceOptionalNamedBlock ]; @@ -743,7 +771,7 @@ InterfaceItem: LetDeclaration // Package // ---------------------------------------------------------------------------- -PackageDeclaration: [ Pub ] Package Identifier LBrace { PackageGroup } RBrace; +PackageDeclaration: [ Pub ] Package Identifier [ WithGenericParameter ] LBrace { PackageGroup } RBrace; PackageGroup: { Attribute } ( LBrace { PackageGroup } RBrace | PackageItem ); diff --git a/testcases/sv/54_generic_function.sv b/testcases/sv/54_generic_function.sv new file mode 100644 index 00000000..e56056a0 --- /dev/null +++ b/testcases/sv/54_generic_function.sv @@ -0,0 +1,17 @@ +module veryl_testcase_Module54; + function automatic logic [10-1:0] __FuncA__10( + input logic [10-1:0] a + ) ; + return a + 1; + endfunction + function automatic logic [20-1:0] __FuncA__20( + input logic [20-1:0] a + ) ; + return a + 1; + endfunction + + logic [10-1:0] _a; + always_comb _a = __FuncA__10(1); + logic [20-1:0] _b; + always_comb _b = __FuncA__20(1); +endmodule diff --git a/testcases/sv/55_generic_module.sv b/testcases/sv/55_generic_module.sv new file mode 100644 index 00000000..01dbd164 --- /dev/null +++ b/testcases/sv/55_generic_module.sv @@ -0,0 +1,32 @@ +module veryl_testcase_Module55; + veryl_testcase___Module55A__Module55B u0 (); + veryl_testcase___Module55A__Module55C u1 (); + veryl_testcase___Module55E__Module55C u2 (); + veryl_testcase___Module55E__Module55D u3 (); +endmodule + +module veryl_testcase___Module55A__Module55B; + veryl_testcase_Module55B u (); +endmodule +module veryl_testcase___Module55A__Module55C; + veryl_testcase_Module55C u (); +endmodule +module veryl_testcase___Module55A__Module55D; + veryl_testcase_Module55D u (); +endmodule + +module veryl_testcase_Module55B; +endmodule + +module veryl_testcase_Module55C; +endmodule + +module veryl_testcase_Module55D; +endmodule + +module veryl_testcase___Module55E__Module55C; + veryl_testcase___Module55A__Module55C u (); +endmodule +module veryl_testcase___Module55E__Module55D; + veryl_testcase___Module55A__Module55D u (); +endmodule diff --git a/testcases/sv/56_generic_interface.sv b/testcases/sv/56_generic_interface.sv new file mode 100644 index 00000000..3ca00804 --- /dev/null +++ b/testcases/sv/56_generic_interface.sv @@ -0,0 +1,19 @@ +module veryl_testcase_Module56; + veryl_testcase___Interface56A__Package56A u0 (); + veryl_testcase___Interface56A__Package56B u1 (); +endmodule + +interface veryl_testcase___Interface56A__Package56A; + logic [veryl_testcase_Package56A::X-1:0] _a; +endinterface +interface veryl_testcase___Interface56A__Package56B; + logic [veryl_testcase_Package56B::X-1:0] _a; +endinterface + +package veryl_testcase_Package56A; + localparam int unsigned X = 1; +endpackage + +package veryl_testcase_Package56B; + localparam int unsigned X = 2; +endpackage diff --git a/testcases/sv/57_generic_package.sv b/testcases/sv/57_generic_package.sv new file mode 100644 index 00000000..8e981a39 --- /dev/null +++ b/testcases/sv/57_generic_package.sv @@ -0,0 +1,11 @@ +module veryl_testcase_Module57; + localparam int unsigned A = veryl_testcase___Package57__1::X; + localparam longint unsigned B = veryl_testcase___Package57__2::X; +endmodule + +package veryl_testcase___Package57__1; + localparam int unsigned X = 1; +endpackage +package veryl_testcase___Package57__2; + localparam int unsigned X = 2; +endpackage diff --git a/testcases/sv/58_generic_struct.sv b/testcases/sv/58_generic_struct.sv new file mode 100644 index 00000000..f50c765e --- /dev/null +++ b/testcases/sv/58_generic_struct.sv @@ -0,0 +1,22 @@ +module veryl_testcase_Module58; + typedef struct packed { + veryl_testcase_Package58::B A; + } __StructA__Package58_B; + typedef struct packed { + C A; + } __StructA__Package58_C; + typedef struct packed { + C A; + } __StructA__C; + + typedef int signed C; + + __StructA__Package58_B _a; + __StructA__Package58_C _b; + __StructA__C _c; +endmodule + +package veryl_testcase_Package58; + typedef int unsigned B; + typedef longint unsigned C; +endpackage diff --git a/testcases/veryl/54_generic_function.veryl b/testcases/veryl/54_generic_function.veryl new file mode 100644 index 00000000..738fa829 --- /dev/null +++ b/testcases/veryl/54_generic_function.veryl @@ -0,0 +1,10 @@ +module Module54 { + function FuncA:: ( + a: input logic, + ) -> logic { + return a + 1; + } + + let _a: logic<10> = FuncA::<10>(1); + let _b: logic<20> = FuncA::<20>(1); +} diff --git a/testcases/veryl/55_generic_module.veryl b/testcases/veryl/55_generic_module.veryl new file mode 100644 index 00000000..9e780576 --- /dev/null +++ b/testcases/veryl/55_generic_module.veryl @@ -0,0 +1,20 @@ +module Module55 { + inst u0: Module55A::; + inst u1: Module55A::; + inst u2: Module55E::; + inst u3: Module55E::; +} + +module Module55A:: { + inst u: T; +} + +module Module55B {} + +module Module55C {} + +module Module55D {} + +module Module55E:: { + inst u: Module55A::; +} diff --git a/testcases/veryl/56_generic_interface.veryl b/testcases/veryl/56_generic_interface.veryl new file mode 100644 index 00000000..650b56b5 --- /dev/null +++ b/testcases/veryl/56_generic_interface.veryl @@ -0,0 +1,16 @@ +module Module56 { + inst u0: Interface56A::; + inst u1: Interface56A::; +} + +interface Interface56A:: { + var _a: logic; +} + +package Package56A { + local X: u32 = 1; +} + +package Package56B { + local X: u32 = 2; +} diff --git a/testcases/veryl/57_generic_package.veryl b/testcases/veryl/57_generic_package.veryl new file mode 100644 index 00000000..760ec04d --- /dev/null +++ b/testcases/veryl/57_generic_package.veryl @@ -0,0 +1,8 @@ +module Module57 { + local A: u32 = Package57::<1>::X; + local B: u64 = Package57::<2>::X; +} + +package Package57:: { + local X: u32 = T; +} diff --git a/testcases/veryl/58_generic_struct.veryl b/testcases/veryl/58_generic_struct.veryl new file mode 100644 index 00000000..7bedfd6c --- /dev/null +++ b/testcases/veryl/58_generic_struct.veryl @@ -0,0 +1,16 @@ +module Module58 { + struct StructA:: { + A: T, + } + + type C = i32; + + var _a: StructA::; + var _b: StructA::; + var _c: StructA:: ; +} + +package Package58 { + type B = u32; + type C = u64; +}